Changeset 91

Show
Ignore:
Timestamp:
Sun Aug 7 10:18:33 2005
Author:
fredrikc
Message:

Some small changes, mostly due to trying to fix memory leak problem.

Files:

Legend:

Unmodified
Added
Removed
Modified

  • trunk/transolution/xliffeditor/gtk_main.py

    r90 r91  
    40 40 from gtk_status_change_dialog import StatusChangeDialog  
    41 41 from gtk_documentviewpanel import DocumentViewPanel  
    42   from document.creators import createDocument,getDocumentFormatter  
      42 from document.creators import createXliffDocumentModel,getDocumentFormatter  
    42 42 from undoredo import UndoException,RedoException  
    43 43  
    …… 
    318 318     def openFile(self,xml):  
    319 319         'Open the xml file and add the Document to the notepad'  
    320           doc = createDocument(xml, use_skeleton=True )  
      320         doc = createXliffDocumentModel(xml, use_skeleton=True )  
    320 320         doc.setFormatter(getDocumentFormatter(self.doc_sub_formatters['Medium']))  
    321 321         self._checkTargetLang(xml,doc.xliff)  
    …… 
    543 543         n = self.notebook.get_current_page()  
    544 544         o = self.notebook.get_nth_page(n)  
    545           sel = self.notebook.remove_page(n)  
      545         self.notebook.remove_page(n)  
    545 545         # Close (destroy) will remove the notebook page also so do this after we call remove_page.  
    546 546         # or we will remove an extra page.  
    547 547         o.close()  
      548         o.destroy()  
    548 549         self._updateGui()  
    549 550          
    …… 
    566 567         print "Save As!"  
    567 568         docpane = self.docpane  
    568           dialog = gtk.FileChooserDialog("Save As",  
      569         dialog = gtk.FileChooserDialog(_("Save As"),  
    568 569                                        None,  
    569 570                                        gtk.FILE_CHOOSER_ACTION_SAVE,  
    …… 
    734 735             try: self.openTm()  
    735 736             except EditorException,e: pass  
    736               else:messageDialog(self.window,"TM Connected:\n"+tm.tm.version())  
      737             else:messageDialog(self.window,_("TM Connected:\n")+tm.tm.version())  
    736 737         else:  
    737 738             tm.tm = None  
    …… 
    775 776         if widget.get_active():  
    776 777             self.docpane.tu_info_panel.show()  
    777               print "Show Tu info!"  
    778 778         else:  
    779 779             self.docpane.tu_info_panel.hide()  
    780               print "Show Tu info"  
    781 780  
    782 781  

  • trunk/transolution/xliffeditor/gtk_documentviewpanel.py

    r70 r91  
    499 499             raise EditorException('Cant close when theres a open TU')  
    500 500         else:  
      501             # Do some cleanup to free objects  
      502             self.doc_model.delete()  
      503             del self.doc_model  
    501 504             self.destroy()  
    502 505  
    …… 
    504 507 import tm  
    505 508  
      509  
    506 510 class DocumentViewPanelTM(DocumentViewPanelBase):  
    507 511     'Expands DocumentViewx with TM operations'  
    …… 
    808 812         self.doc_model.xupdate()  
    809 813         return changes  
    810    
    811    
    812   ##from xliffsegment import XliffError,Model  

  • trunk/transolution/xliffeditor/gtk_tustatus.py

    r2 r91  
    157 157             self.tu_state.set_sensitive(True)  
    158 158  
    159           self.unobserve()  
      159 ##        self.unobserve()  
    159 159         self.observe(tu)  
    160 160         self.xupdate(tu)  

  • trunk/transolution/xliffeditor/xliffparser_ng.py

    r61 r91  
    187 187         return u'\n'.join(r)  
    188 188  
      189     def __del__(self):  
      190         print "delete dom"  
      191         try:  
      192             self.xliffdoc.unlink()  
      193         except AttributeError,e:  
      194             pass  
      195         del self.xliffdoc  
      196  
    189 197 class NodeWrapper(object):  
    190 198     def __init__(self,filenode):  
    …… 
    294 302             self.bodies.append(body_node)  
    295 303  
      304     def __del__(self):  
      305         print "delete skeleton dom"  
      306         try:  
      307             self.skldoc.unlink()  
      308         except AttributeError,e:  
      309             pass  
      310  
      311         try:del self.skldoc  
      312         except AttributeError,e:  
      313             pass  
    296 314  
    297 315 class Header(NodeWrapper):  

  • trunk/transolution/xliffeditor/general.py

    r2 r91  
    1   from sets import Set  
    2    
    3 1 class EditorException(Exception): pass  
    4 2 class XliffError(Exception): pass  
    5 3 InterfaceErr =  NotImplementedError('must be implemented in subclasses')  
    6 4  
      5 import weakref  
    7 6 class Observer(object):  
    8 7     def __init__(self):  
    9           self.subject = None  
      8         pass  
    9 8     def observe(self,subject):  
    10           self.subject = subject  
    11           self.subject.subscribe(self)  
      9         subject.subscribe(self)  
      10  
      11     def unobserve(self,subject):  
      12         if subject is not None:  
      13             subject.unsubscribe(self)  
    12 14  
    13       def unobserve(self):  
    14           if not(self.subject is None):  
    15               self.subject.unsubscribe(self)  
    16            
    17 15     def xupdate(self,*args,**kwargs):  
    18 16         raise InterfaceErr  
    …… 
    22 20     'Obeserver pattern interface'  
    23 21     def __init__(self):  
    24           self.observers = Set()  
      22         self._observers = weakref.WeakKeyDictionary()  
      23          
    25 24     # observer pattern interface  
    26 25     def subscribe(self,observer):  
    27           self.observers.add(observer)  
      26         self._observers[observer] = None  
      27  
    28 28     def unsubscribe(self,observer):  
    29           self.observers.remove(observer)  
      29         if observer in self._observers:  
      30             del self._observers[observer]  
      31  
    30 32     def xnotify(self,*args,**kwargs):  
    31   #        print "update"  
    32 33         if not (args):  
    33 34             args = [self,]  
    34           for o in self.observers:  
      35         for o in self._observers:  
    34 35             o.xupdate(*args,**kwargs)  
      36  

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

    r82 r91  
    64 64         'Add a segment to document'  
    65 65         self.segs.append(seg)  
    66           seg.subscribe(self)  
    67           #seg.setParent(self)  
      66         self.observe(seg)  
    68 67  
    69 68     def getSegByTextIndex(self,ti):  
    …… 
    181 180             self.xliff =xliff  
    182 181         del self.segs  
    183   ##        for seg in self.segs:  
    184   ##            del seg  
    185 182         self.use_skeleton = use_skeleton  
    186 183  
    …… 
    196 193                 self.addSeg(seg)  
    197 194  
    198    
    199    
    200 195         print "Xliff Done"  
      196  
      197     def delete(self):  
      198         # the tree must be unlinked to free objects  
      199         self.tree.unlink()  
      200         del self.tree  
      201         del self.segs  
      202         del self.xliff  

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

    r82 r91  
    43 43     def buildTree(self, segments):  
    44 44         print "Building Tree"  
    45           if self.root: del self.root  
      45         if self.root:  
      46             self.unlink()  
      47             del self.root  
    46 48         # inserts a new data  
    47 49         root = Node(None)  
    …… 
    115 117             print (' '*indent) + str(node.key) + str(node.seg)  
    116 118  
      119     def unlink(self):  
      120         'unlink all nodes in the tree to free objects'  
      121         if self.root is not None:  
      122             self._unlink(self.root)  
      123         self.root = None  
      124          
      125     def _unlink(self,node):  
      126         del node.parent  
      127         if node.__class__ is LeafNode:  
      128             # leafnode  
      129             del node.seg.treenode  
      130             del node.seg  
      131         else:  
      132             for c in node.childs:  
      133                 self._unlink(c)  
      134             del node.childs  
      135         del node  
      136                  
      137     def __del__(self):  
      138         try:         
      139             self.unlink()  
      140         except AttributeError,e:  
      141             pass  
    117 142  
    118 143 def testGetBounds():  

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

    r51 r91  
    4 4 from document_formatter import DocumentFormatter  
    5 5  
    6   def createDocument(xml,use_skeleton=True):  
      6 def createXliffDocumentModel(xml,use_skeleton=True):  
    6 6     'factory for ModelDoc that sets up formatters and styles etc.'  
    7 7     xliff = XliffDocument(xml)  

  • trunk/xliffeditor.py

    r22 r91  
    19 19 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA  
    20 20 #  
      21  
      22 GC_DEBUG = 0  
    21 23 import transolution.xliffeditor.gtk_main as gtk_main  
    22   gtk_main.main()  
      24  
      25 if GC_DEBUG:  
      26     import sys  
      27     sys.stderr = sys.stdout  
      28     import gc  
      29     gc.enable()  
      30     gc.set_debug(gc.DEBUG_LEAK)  
      31     gtk_main.main()  
      32     print gc.garbage  
      33 else:  
      34     gtk_main.main()