Changeset 97

Show
Ignore:
Timestamp:
Fri Aug 12 10:56:07 2005
Author:
fredrikc
Message:

Converted to use the new observer pattern implementation.

Files:

Legend:

Unmodified
Added
Removed
Modified

  • trunk/transolution/xliffeditor/subseg.py

    r81 r97  
    41 41         # Set the source-text widget model to the current node  
    42 42         source_seg_model.setRootNode(self.tu.getSourceNode())  
    43           source_seg_model.xnotify()  
      43         source_seg_model.notifyObservers()  
    43 43         # Set the target-text widget model to the current target node  
    44 44         try:  
    …… 
    48 48             print e  
    49 49             target_seg_model.setRootNode(None)  
    50           target_seg_model.xnotify()  
      50         target_seg_model.notifyObservers()  
    50 50         if insertionNode:  
    51 51             # set caret to subsegs end  

  • trunk/transolution/xliffeditor/gtk_main.py

    r96 r97  
    33 33 import gtk.glade  
    34 34  
    35   from general import Observer,Notifier  
      35 from transolution.observer import Observer,Observable  
    35 35 from gtk_utils import askOk,messageDialog,aboutDialog,cb_get_active_text,entryDialog,create_tag_table,fileChooserDialog,dropDownDialog  
    36 36 from general import EditorException  
    …… 
    197 197         from document.segments import TuSegment  
    198 198         self.docpane.doc_model.setDirty(TuSegment)  
    199           self.docpane.doc_model.xnotify()  
      199         self.docpane.doc_model.notifyObservers()  
    199 199 ##        self.docpane.document_control.showInsertPoint()  
    200 200  
    …… 
    216 216  
    217 217             self.docpane.source_seg_model.setFormatter(f)  
    218               self.docpane.source_seg_model.xnotify()  
      218             self.docpane.source_seg_model.notifyObservers()  
    218 218             self.docpane.target_seg_model.setFormatter(f)  
    219               self.docpane.target_seg_model.xnotify()  
      219             self.docpane.target_seg_model.notifyObservers()  
    219 219 ##            self.docpane.target_seg_model.showInsertPoint()  
    220 220  
    …… 
    239 239             from document.segments import External  
    240 240             self.docpane.doc_model.setDirty(External)  
    241               self.docpane.doc_model.xupdate()  
      241             self.docpane.doc_model.xupdate(None,None,None)  
    241 241         else:  
    242 242             # no skeleton used before so we need to reparse using skeleton  
    243 243             self.docpane.document_control.buf.clear()  
    244 244             self.docpane.doc_model.parseXliff(use_skeleton=True)  
    245               self.docpane.doc_model.xupdate()  
      245             self.docpane.doc_model.xupdate(None,None,None)  
    245 245             return True  
    246 246  
    …… 
    256 256          
    257 257         self.docpane.doc_model.parseXliff(use_skeleton=False)  
    258           self.docpane.doc_model.xupdate()  
      258         self.docpane.doc_model.xupdate(None,None,None)  
    258 258         return True  
    259 259  
    …… 
    275 275         from document.segments import TuSegment  
    276 276         self.docpane.doc_model.setDirty(TuSegment)  
    277           self.docpane.doc_model.xupdate()  
      277         self.docpane.doc_model.xupdate(None,None,None)  
    277 277         return True  
    278 278  
    …… 
    284 284         from document.segments import TuSegment  
    285 285         self.docpane.doc_model.setDirty(TuSegment)  
    286           self.docpane.doc_model.xupdate()  
      286         self.docpane.doc_model.xupdate(None,None,None)  
    286 286         return True  
    287 287          
    …… 
    336 336  
    337 337         # update document view  
    338           doc.xnotify()  
      338         doc.notifyObservers()  
    338 338  
    339 339         # setup mode  
    …… 
    791 791         model.protect_tags = w.get_active()  
    792 792         print "TagProtection:%s"%(('off','on')[model.protect_tags],)  
    793           model.xnotify()  
      793         model.notifyObservers()  
    793 793         self._updateGui()  
    794 794  

  • trunk/transolution/xliffeditor/gtk_documenteditor.py

    r59 r97  
    1 1 import gtk  
    2 2 import pango  
    3   from general import Observer,Notifier,EditorException  
      3 from general import EditorException  
      4 from transolution.observer import Observer,Observable  
    4 5 from gtk_basetextbuf import BaseTextBuffer  
    5 6  
    …… 
    16 17         self.model = model  
    17 18         # tell us to observer model for gui changes  
    18           self.observe(self.model)  
      19         self.subscribeToObservable(self.model,'xupdate')  
    18 19          
    19       def xupdate(self,doc):  
      20     def xupdate(self,doc,event,msg):  
    19 20         '''  
    20 21         observe/notify interface.  
    …… 
    74 75 from document.segments import External,TuSegment,FileInfo  
    75 76  
    76   class DocumentEdit(gtk.TextView,Notifier):  
      77 class DocumentEdit(gtk.TextView,Observable):  
    76 77     def __init__(self,*args,**kwargs):  
    77 78         gtk.TextView.__init__(self,*args,**kwargs)  
    78           Notifier.__init__(self)  
      79         Observable.__init__(self)  
    78 79         self.connect("key_press_event", self.keyPressed)  
    79 80  
    …… 
    181 182  
    182 183         # notify obervers that we have changed  
    183           self.xnotify(seg)  
      184         self.notifyObservers(msg=seg)  
    183 184         self.showInsertPoint()  
    184 185 ##        self.buf.emit_stop_by_name("mark-set")  

  • trunk/transolution/xliffeditor/xliffsegment.py

    r67 r97  
    7 7 from sets import Set  
    8 8 from formatters import FullFormatter,MinimalFormatter  
    9   from general import XliffError,Notifier  
      9 from general import XliffError  
      10 from transolution.observer import Observable  
    10 11 from transolution.xmlutils import getText,getNodeSpan,removeNodes,copyNodes,pasteNodes,splitText  
    11 12 from transolution.xmlutils import getNodeAttr,setNodeAttr  
    …… 
    327 328      
    328 329          
    329   class Model(UndoRedoXliff,Notifier):  
      330 class Model(UndoRedoXliff,Observable):  
    329 330     'Adds obeserver pattern interface to Xliff'  
    330 331      
    …… 
    334 335  
    335 336         # observer pattern interface  
    336           Notifier.__init__(self)  
      337         Observable.__init__(self)  
    336 337  
    337 338  

  • trunk/transolution/xliffeditor/gtk_documentviewpanel.py

    r95 r97  
    14 14 from gtk_utils import askOk,askDialog,entryDialog  
    15 15  
    16   from general import Observer,Notifier  
      16 from transolution.observer import Observer,Observable  
    16 16 from xliffsegment import XliffError,Model #TODO: Model name is to generic  
    17 17  
    …… 
    116 116  
    117 117         # Observe document text widget for segment changes  
    118           self.observe(self.document_control)  
      118         self.subscribeToObservable(self.document_control,'xupdate')  
      119  
    119 120          
    120 121         self.documentbuffer = self.document_control.get_buffer()  
    …… 
    211 212         self.target_control.get_buffer().setModel(self.target_seg_model)  
    212 213  
    213       def xupdate(self,seg):  
      214     def xupdate(self,observable, event, seg):  
    213 214         'called by document_control when selected segment changes'  
    214 215         self.source_seg_model.setRootNode(seg.tu.getSourceNode())  
    215           self.source_seg_model.xnotify()  
      216         self.source_seg_model.notifyObservers()  
    215 216         try:  
    216 217             target_node = seg.tu.getTargetNode()  
    …… 
    222 223         else:  
    223 224             self.target_seg_model.setRootNode(target_node)  
    224           self.target_seg_model.xnotify()  
      225         self.target_seg_model.notifyObservers()  
    224 225         # update TU status panel  
    225 226         self.tu_info_panel.setTu(seg.tu)  
    …… 
    335 336         tu = self.document_control.current_seg.tu  
    336 337         tu.approved = 'yes'  
    337           tu.xnotify()  
      338         tu.notifyObservers()  
    337 338  
    338 339  
    …… 
    342 343         self.tu_info_panel.tu.addNote()  
    343 344         # update gui  
    344           self.tu_info_panel.xupdate(self.tu_info_panel.tu)  
      345         self.tu_info_panel.xupdate(None,self.tu_info_panel.tu)  
    344 345 ##        self._segClose(commit=False)  
    345 346  
    …… 
    549 550             tu.state = 'needs-review-adaptation'  
    550 551          
    551           tu.xnotify()  
      552         tu.notifyObservers()  
    551 552  
    552 553     def openTransUnit(self,*args,**kwargs):  
    …… 
    598 599  
    599 600  
    600       def xupdate(self,seg,*args,**kwargs):  
    601           ret = DocumentViewPanelBase.xupdate(self,seg,*args,**kwargs)  
    602   ##        self.showContextGroups(seg)  
    603           return ret  
    604            
    605    
    606 601  
    607 602 class DocumentViewPanel(DocumentViewPanelTM):  
    …… 
    669 664         self.document_control.get_buffer().setInsertionPoint(start)  
    670 665         # update TU status info in document view window  
    671           self.document_control.xnotify(f.seg)  
      666         self.document_control.notifyObservers(msg=f.seg)  
    671 666  
    672 667          
    …… 
    731 726         self.search_object.foundobj.replace(s['replace_phrase'])  
    732 727  
    733           self.source_seg_model.xnotify()  
    734           self.target_seg_model.xnotify()  
      728         self.source_seg_model.notifyObservers()  
      729         self.target_seg_model.notifyObservers()  
    735 730         # save changes to segment  
    736 731         try:  
    …… 
    763 758  
    764 759         #update UI  
    765           self.source_seg_model.xnotify()  
    766           self.target_seg_model.xnotify()  
      760         self.source_seg_model.notifyObservers()  
      761         self.target_seg_model.notifyObservers()  
    767 762  
    768           self.doc_model.xupdate()  
      763         self.doc_model.xupdate(None,None,None)  
    768 763  
    769 764         search_dlg.grab_focus()  
    …… 
    810 805                 changed = False  
    811 806                 seg.dirty = True  
    812           self.doc_model.xupdate()  
      807         self.doc_model.xupdate(None,None,None)  
    812 807         return changes  

  • trunk/transolution/xliffeditor/gtk_tustatus.py

    r91 r97  
    6 6 import gtk.glade  
    7 7 from gtk_utils import askOk,messageDialog,create_textbuffer_tags,CustomHandler  
    8   from general import Observer,Notifier  
      8 from transolution.observer import Observer,Observable  
    8 8 from tm.utils import getTextWithTags  
    9 9 from document.tu.state_maps import getTuStates,getTuStatesQualifiers  
    …… 
    100 100         self.setTu(None)  
    101 101          
    102       def xupdate(self,tu):  
      102     def xupdate(self,tu,event,msg):  
    102 102         org = self.interactive  
    103 103         self.interactive = False # disable interactive event checks  
    …… 
    157 157             self.tu_state.set_sensitive(True)  
    158 158  
    159   ##        self.unobserve()  
    160           self.observe(tu)  
    161           self.xupdate(tu)  
      159         self.subscribeToObservable(tu, "xupdate")  
      160         self.xupdate(tu,None,None)  
    162 161         self.tu = tu  
    163 162  
    164 163     def onAlttransExpanderActivate(self,*args):  
    165 164         print "Alttrans EXPAND"  
    166           self.xupdate(self.tu)  
      165         self.xupdate(self.tu,None,None)  
    166 165     def onContextExpanderActivate(self,*args):  
    167 166         print "Context EXPAND"  
    168           self.xupdate(self.tu)  
      167         self.xupdate(self.tu,None,None)  
    168 167  
    169 168     def onCbTranslateToggled(self,*args):  
    …… 
    178 177         if self.tu:  
    179 178             self.tu.approved = widget.get_active()  
    180               self.tu.xnotify()  
      179             self.tu.notifyObservers()  
    180 179         return True  
    181 180  
    …… 
    192 191         else:  
    193 192             del self.tu.state  
    194           self.tu.xnotify()  
      193         self.tu.notifyObservers()  
    194 193         return True  
    195 194  
    …… 
    200 199             self.tu.state_qualifier = entry.get_text()  
    201 200         else: del self.tu.state_qualifier  
    202           self.tu.xnotify()  
      201         self.tu.notifyObservers()  
    202 201         return True  
    203 202          

  • trunk/transolution/xliffeditor/general.py

    r93 r97  
    3 3 InterfaceErr =  NotImplementedError('must be implemented in subclasses')  
    4 4  
    5   import weakref  
    6   class Observer(object):  
    7       def __init__(self):  
    8           pass  
    9       def observe(self,subject):  
    10           subject.subscribe(self)  
    11    
    12       def unobserve(self,subject):  
    13           if subject is not None:  
    14               subject.unsubscribe(self)  
    15    
    16       def xupdate(self,*args,**kwargs):  
    17           raise InterfaceErr  
    18    
    19   class Notifier(object):  
    20       'Obeserver pattern interface'  
    21       def __init__(self):  
    22           self._observers = weakref.WeakKeyDictionary()  
    23            
    24       # observer pattern interface  
    25       def subscribe(self,observer):  
    26           self._observers[observer] = None  
    27    
    28       def unsubscribe(self,observer):  
    29           if observer in self._observers:  
    30               del self._observers[observer]  
    31    
    32       def xnotify(self,*args,**kwargs):  
    33           if not (args):  
    34               args = [self,]  
    35           for o in self._observers:  
    36               o.xupdate(*args,**kwargs)  
    37    
      5 ##import weakref  
      6 ##class Observer(object):  
      7 ##    def __init__(self):  
      8 ##        pass  
      9 ##    def observe(self,subject):  
      10 ##        subject.subscribe(self)  
      11 ##  
      12 ##    def unobserve(self,subject):  
      13 ##        if subject is not None:  
      14 ##            subject.unsubscribe(self)  
      15 ##  
      16 ##    def xupdate(self,*args,**kwargs):  
      17 ##        raise InterfaceErr  
      18 ##  
      19 ##class Notifier(object):  
      20 ##    'Obeserver pattern interface'  
      21 ##    def __init__(self):  
      22 ##        self._observers = weakref.WeakKeyDictionary()  
      23 ##         
      24 ##    # observer pattern interface  
      25 ##    def subscribe(self,observer):  
      26 ##        self._observers[observer] = None  
      27 ##  
      28 ##    def unsubscribe(self,observer):  
      29 ##        if observer in self._observers:  
      30 ##            del self._observers[observer]  
      31 ##  
      32 ##    def xnotify(self,*args,**kwargs):  
      33 ##        if not (args):  
      34 ##            args = [self,]  
      35 ##        for o in self._observers:  
      36 ##            o.xupdate(*args,**kwargs)  
      37 ##  

  • trunk/transolution/xliffeditor/undoredo.py

    r2 r97  
    76 76         self.dict = kwargs  
    77 77          
    78       def xupdate(self,obj):  
      78     def xupdate(self, obj,event,msg):  
    78 78         for key,val in self.dict.items():  
    79 79             setattr(obj,key,val)  

  • trunk/transolution/xliffeditor/gtk_tagedit.py

    r67 r97  
    1 1 import gtk  
    2 2  
    3   from general import Observer  
      3 from transolution.observer import Observer  
    3 3 from xliffsegment import XliffError  
    4 4 from gtk_basetextbuf import BaseTextBuffer  
    …… 
    60 60         self.model = model  
    61 61         # tell us to observer model for gui changes  
    62           self.observe(self.model)  
      62         self.subscribeToObservable(self.model, "xupdate")  
    62 62  
    63 63     def delete_range(self,textbuf,start,end,interactive=True):  
    …… 
    93 93 ##        else:  
    94 94 ##            # update observers (views)  
    95   ##            self.model.xnotify()  
      95 ##            self.model.notifyObservers()  
    95 95 ##            # move insertion point to reflect the inserted char  
    96 96 ##            tw.setInsertionPoint(tw.getInsertionPoint()+1)  
    97 97  
    98 98  
    99       def xupdate(self,seg):  
      99     def xupdate(self, seg, event,msg):  
    99 99         'Update TextCtrl with formatted segment data'  
    100 100         print "update"  
    …… 
    136 136         model = self.getModel()  
    137 137         model.undo()  
    138           model.xnotify()  
      138         model.notifyObservers()  
    138 138  
    139 139     def redo(self,*args):  
    …… 
    142 142         model = self.getModel()  
    143 143         model.redo()  
    144           model.xnotify()  
      144         model.notifyObservers()  
    144 144  
    145 145     def cut_clipboard(self,*args):  
    …… 
    151 151         nodelist =  buf.model.cutNodesByTextIndexWithUndo(start,end)  
    152 152         clipboard.setClipBoardNodeList(nodelist,text)  
    153           buf.model.xnotify()  
      153         buf.model.notifyObservers()  
    153 153         buf.setInsertionPoint(start)  
    154 154         return True  
    …… 
    180 180  
    181 181             buf.model.pasteNodesAtTextIndexWithUndo(start,nodelist)  
    182               buf.model.xnotify()  
      182             buf.model.notifyObservers()  
    182 182             buf.setInsertionPoint(start+len(text))  
    183 183         else: print "Nothing to paste"  

  • trunk/transolution/xliffeditor/document/document.py

    r91 r97  
    1 1 __doc__ = 'main document model'  
    2 2  
    3   from transolution.xliffeditor.general import Notifier,Observer,EditorException  
      3 from transolution.observer import Observable,Observer  
      4 from transolution.xliffeditor.general import EditorException  
    4 5 from segments import External,TuSegment,FileInfo,TuInfo  
    5 6 from tree import IndexTree  
    …… 
    17 18         self.segindex = segindex  
    18 19  
    19   class DocumentBase(Notifier,Observer):  
      20 class DocumentBase(Observable,Observer):  
    19 20     'Base Document model colletor for External and TuSegment segments'  
    20 21     def __init__(self):  
    21           Notifier.__init__(self)  
      22         Observable.__init__(self)  
    21 22         Observer.__init__(self)  
    22 23         self.segs = []  
    …… 
    64 65         'Add a segment to document'  
    65 66         self.segs.append(seg)  
    66           self.observe(seg)  
      67         self.subscribeToObservable(seg, "xupdate")  
      68  
    67 69  
    68 70     def getSegByTextIndex(self,ti):  
    …… 
    93 95  
    94 96  
    95       def xupdate(self,seg=None):  
      97     def xupdate(self, observable,event,seg=None):  
    95 97         'observer interface'  
    96           self.xnotify()  
      98         self.notifyObservers()  
    96 98  
    97 99 from constraints import unTranslated,unApproved  
    …… 
    157 159 from transolution.xliffeditor.xliffparser_ng import XliffException  
    158 160      
    159   class ModelDoc(DocumentEditor,Notifier):  
      161 class ModelDoc(DocumentEditor,Observable):  
    159 161     '''Document Model  
    160          Adds Notifier interface so we can notify GUI to update  
      162        Adds Observable interface so we can notify GUI to update  
    160 162     '''  
    161 163     def __init__(self,xliff=None,formatters={}):  
    162 164         DocumentEditor.__init__(self)  
    163           Notifier.__init__(self)  
      165         Observable.__init__(self)  
    163 165         self.xliff = xliff  
    164 166         self.formatters = formatters # document formatters  

  • trunk/transolution/xliffeditor/document/tu/tu.py

    r2 r97  
    1   from transolution.xliffeditor.general import Observer,Notifier  
      1 from transolution.observer import Observable,Observer  
    1 1 from transolution.xmlutils import XmlError,getNodeAttr,setNodeAttr,setCreateNodeAttr,getNodes,getElementsByTagName  
    2 2 from tu_status_wrapper import TuStatusWrapper  
    …… 
    9 9     pass  
    10 10  
    11   class TranslationUnitBase(TuStatusWrapper,Notifier):  
      11 class TranslationUnitBase(TuStatusWrapper,Observable):  
    11 11     'Wraps a Xliff segment to allow Translation unit operations on it'  
    12 12     def __init__(self,tu_node):  
    13           Notifier.__init__(self)  
      13         Observable.__init__(self)  
    13 13  
    14 14         if tu_node.tagName != 'trans-unit':  
    …… 
    48 48         self.open = True  
    49 49         # notify observers  
    50           self.xnotify()  
      50         self.notifyObservers()  
    50 50  
    51 51  
    …… 
    69 69         self.open = False  
    70 70         # notify observers  
    71           self.xnotify()  
      71         self.notifyObservers()  
    71 71         self.backuptarget = None  
    72 72  
    …… 
    77 77         self.open = False  
    78 78         # notify observers  
    79           self.xnotify()  
      79         self.notifyObservers()  
    79 79         self.backuptarget = None  
    80 80  

  • trunk/transolution/xliffeditor/document/document_search.py

    r2 r97  
    1 1 __doc__ = '''Provides functionallity to search & replace text in a document model'''  
    2 2  
    3   from transolution.xliffeditor.general import Notifier,Observer  
      3 from transolution.observer import Observable,Observer  
    3 3 from transolution.xliffeditor.xliffsegment import Model  
    4 4 from transolution.xliffeditor.formatters import Formatter,MinimalFormatter,FullFormatter  
    …… 
    9 9 class SearchException(Exception):pass  
    10 10  
    11   class FoundObject(Notifier):  
    12       'Object stores find/replace information, implements Notifier to notify observers on replace'  
      11 class FoundObject(Observable):  
      12     'Object stores find/replace information, implements Observable to notify observers on replace'  
    13 13     def __init__(self,seg,model,segtype,pos,search_str):  
    14           Notifier.__init__(self)  
      14         Observable.__init__(self)  
    14 14         self.seg = seg  
    15 15         self.model = model  
    …… 
    25 25         self.model.deleteTextWithUndo(self.start,self.end)  
    26 26         self.model.insertTextWithUndo(self.start,replace_str)  
    27           self.xnotify()  
      27         self.notifyObservers()  
    27 27         # set flag that data in segment has changed  
    28 28         self.seg.dirty = True  
    …… 
    68 68                 for res in self.seg_searcher.search(model,self.searchterm,reverse,self.case):  
    69 69                     self.foundobj = FoundObject(seg,model,'source',res,self.searchterm)  
    70                       self.seg_searcher.observe(self.foundobj)  
      70                     self.seg_searcher.subscribeToObservable(self.foundobj,"xupdate")  
      71  
    71 72                     yield self.foundobj  
    72 73             if self.search_target:  
    …… 
    78 79                     for res in self.seg_searcher.search(model,self.searchterm,reverse,self.case):  
    79 80                         self.foundobj = FoundObject(seg,model,'target',res,self.searchterm)  
    80                           self.seg_searcher.observe(self.foundobj)  
      81                         self.seg_searcher.subscribeToObservable(self.foundobj,"xupdate")  
    80 81  
    81 82                         yield self.foundobj  
    …… 
    88 89         self.dirty = False  
    89 90          
    90       def xupdate(self,subject=None):  
      91     def xupdate(self, observable,event,subject=None):  
    90 91         'called when a foundobject has done a replace'  
    91 92         self.replace_offset = len(subject.replace_str) - len(subject.search_str)  

  • trunk/transolution/xliffeditor/document/segments.py

    r55 r97  
    1   from transolution.xliffeditor.general import Notifier,Observer  
      1 from transolution.observer import Observable,Observer  
    1 1 from tu import TranslationUnit,TuException  
    2 2  
    3 3 bg_colors = {}  
    4 4  
    5   class Segment(Notifier):  
      5 class Segment(Observable):  
    5 5     'Base object for External and TuSegment segments'  
    6 6     formatter = None  
    7 7     def __init__(self,node):  
    8           Notifier.__init__(self)  
      8         Observable.__init__(self)  
    8 8         self._node = node  
    9 9         self.dirty = True # flag that tells that ui needs to update  
    …… 
    68 68         self.tu = TranslationUnit(self._node)  
    69 69         # observe TU for changes  
    70           self.observe(self.tu)  
    71            
    72       def xupdate(self,subject):  
      70         self.subscribeToObservable(self.tu, "xupdate")  
      71  
      72  
      73     def xupdate(self, observable,event,subject):  
    73 74         'observer interface called by TUs notify'  
    74 75         self.dirty = True  
    75 76         # Update segment to  
    76           self.xnotify()  
      77         self.notifyObservers()  
    76 77          
    77 78     def getTU(self):