[BACK]Return to ImageArchive.py CVS log [TXT] [DIR] Up to [Repository] / ImageArchive

Diff for /ImageArchive/ImageArchive.py between versions 1.1.1.1 and 1.27

version 1.1.1.1, 2003/12/03 08:46:45 version 1.27, 2004/08/03 13:44:18
Line 9  import os Line 9  import os
 import os.path  import os.path
 import urllib  import urllib
 import xml.dom.minidom  import xml.dom.minidom
   import operator
   
 def getText(nodelist):  def getText(nodelist):
           
Line 20  def getText(nodelist): Line 21  def getText(nodelist):
     return rc      return rc
   
   
 class ImageDigilib(SimpleItem,Persistent,Implicit):  class ImageDigilib(Folder,Persistent,Implicit):
     """Anzeige object fuer digilib"""      """Anzeige object fuer digilib"""
     meta_type="ImageDigilib"      meta_type="ImageDigilib"
   
     def __init__(self,id,filename):      leiden_meta_fields=['image_id','date','country','place','people','description','photographer']
   
       manage_options = Folder.manage_options+(
           
           {'label':'Add Metadata','action':'addMetaObjectForm'},
           
           )
   
       def addMetaObject(self,id,RESPONSE=None):
           """Add an MetaObject"""
           objectType=getattr(self.Control_Panel.Products.ImageMetaData,self.genericMetaDataType)
   
           request=self.REQUEST
           objectCreate=objectType.createObjectManager(id,request)
   
           self._setObject(id,objectCreate)
           
           objectCreate.propertysheets.meta.manage_editProperties(request)
   
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
           
   
   
       def addMetaObjectForm(self):
           """Add Form"""
           pt=PageTemplateFile('Products/ImageArchive/zpt/addMetaObject.zpt').__of__(self)
           return pt()        
   
   
       def __init__(self,id,filename,meta=None):
         self.id=id          self.id=id
         self.title=filename          self.title=filename
         self.filename=filename          self.filename=filename
           self.meta=meta
   
       def getMeta(self):
           """ausgabe der metadaten"""
           return self.meta
   
     def uploadImage(self,fileupload,path_name):      def uploadImage(self,fileupload,path_name):
         """upload an Image from an Requast"""          """upload an Image from an Requast"""
Line 37  class ImageDigilib(SimpleItem,Persistent Line 74  class ImageDigilib(SimpleItem,Persistent
         f=open(filename,"w")          f=open(filename,"w")
         f.write(filedata)          f.write(filedata)
         f.close()          f.close()
           try:
         os.chmod(filename,0644)          os.chmod(filename,0644)
           except:
               """hack"""
   
           os.popen("ssh nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat.pl %s /mpiwg/temp/online/scaled/small 100 &"% self.ImageViewerPath)
   
       
   
       
   
     def download(self):      def download(self):
         """download"""          """download"""
         path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+self.filename+"&mo=file"          path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+self.filename+"&mo=rawfile,hires"
         #self.REQUEST.SESSION['string']="<img src=\"%s\">"% path          #self.REQUEST.SESSION['string']="<img src=\"%s\">"% path
         #pt=PageTemplateFile('Products/ImageArchive/thumb.zpt').__of__(self)          #pt=PageTemplateFile('Products/ImageArchive/thumb.zpt').__of__(self)
         return self.REQUEST.RESPONSE.redirect(path)          return self.REQUEST.RESPONSE.redirect(path)
           
     def thumb(self):      def thumb(self):
         """show thumb"""          """show thumb"""
         if not os.path.exists("/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+self.filename):          thumbname=os.path.splitext(self.filename)[0]+".jpg"
             #image=urllib.urlopen("http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+self.filename+"&dw=150").read()          ## if not os.path.exists("/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+thumbname):
             #f=open("/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+self.filename,"w")  ##             image=urllib.urlopen("http://nausikaa2.rz-berlin.mpg.de:18080/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+self.filename+"&dw=150&mo=lores").read()
             #f.write(image)  ##             f=open("/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+thumbname,"w")
             #f.close()  ##             f.write(image)
             os.popen("ssh nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat.pl %s /mpiwg/temp/online/scaled/small 150 &"% self.ImageViewerPath)  ##             f.close()
               ##             os.popen("ssh nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat.pl %s /mpiwg/temp/online/scaled/small 150 &"% self.ImageViewerPath)
                       
         #path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+self.filename+"&dw=100&dh=100"          #DEVEL:take nausikaa for server solution
         path="/thumbs"+self.ImageViewerPath+"/"+self.filename          
         self.REQUEST.SESSION['string']="<img src=\"%s\">"% path          path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+self.filename+"&dw=100&dh=100&mo=lores"
         pt=PageTemplateFile('Products/ImageArchive/thumb.zpt').__of__(self)          #path="/mpiwg/online/"+self.ImageViewerPath+"/"+thumbname
           self.REQUEST.SESSION['string']="<img border=\"0\" src=\"%s\">"% path
           pt=PageTemplateFile('Products/ImageArchive/zpt/thumb.zpt').__of__(self)
         return pt()          return pt()
           
     def index_html(self):      def index_html(self):
         """show image"""          """show image"""
         path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/digilib.jsp?fn="+self.ImageViewerPath+"/"+self.filename          #DEVELOP: take first one for server
           
           path="http://content.mpiwg-berlin.mpg.de/zogilib_images?lv=2&fn="+self.ImageViewerPath+"/"+self.filename
   
           #path="http://localhost:8080/mpiwg/online/"+self.ImageViewerPath+"/"+self.filename
         #self.REQUEST.SESSION['string']="<img src=\"%s\">"% path          #self.REQUEST.SESSION['string']="<img src=\"%s\">"% path
         #pt=PageTemplateFile('Products/ImageArchive/thumb.zpt').__of__(self)          #pt=PageTemplateFile('Products/ImageArchive/thumb.zpt').__of__(self)
         return self.REQUEST.RESPONSE.redirect(path)          return self.REQUEST.RESPONSE.redirect(path)
Line 72  class ImageDigilib(SimpleItem,Persistent Line 124  class ImageDigilib(SimpleItem,Persistent
           
 def manage_AddImageDigilibForm(self):  def manage_AddImageDigilibForm(self):
     """Nothing yet"""      """Nothing yet"""
     pt=PageTemplateFile('Products/ImageArchive/AddImageDigilibForm.zpt').__of__(self)      pt=PageTemplateFile('Products/ImageArchive/zpt/AddImageDigilibForm.zpt').__of__(self)
     return pt()      return pt()
           
 def manage_AddImageDigilib(self,id,fileupload,RESPONSE=None):  def manage_AddImageDigilib(self,id,fileupload,meta=None,RESPONSE=None):
     """Add ImageCollection"""      """Add ImageCollection"""
     #fileupload=self.REQUEST['fileupload']      #fileupload=self.REQUEST['fileupload']
     newObj=ImageDigilib(id,fileupload.filename)      newObj=ImageDigilib(id,fileupload.filename,meta)
           
     self._setObject(id,newObj)      self._setObject(id,newObj)
     getattr(self,id).uploadImage(fileupload,self.ImageStoragePath)      getattr(self,id).uploadImage(fileupload,self.ImageStoragePath)
Line 91  class ImageCollection(Folder, Persistent Line 143  class ImageCollection(Folder, Persistent
     """Sammelordner für Bilder"""      """Sammelordner für Bilder"""
     meta_type="ImageCollection"      meta_type="ImageCollection"
   
     def __init__(self,id,title,ImageStoragePath,ImageViewerPath):      genericMetaDataType="leiden_meta"
   
       leiden_meta_fields=['image_id','date','country','place','people','description','photographer']
   
       
       defaultMetaString="http://fm-web.mpiwg-berlin.mpg.de:8050/FMRes/FMPJS?-db=Wissenschaftlerportraits.fp5&-layID=69&-token=25&-max=1&-format=formvwcss.htm&-mode=browse&images::filename=%s&-find" ## TEST FUER IMAGEDATENBANK WP
   
       def scaleThumbs(self):
           """scale thumbs"""
           os.popen("ssh nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat.pl %s /mpiwg/temp/online/scaled/small 100 &"% self.ImageViewerPath)
           return "RESCALING STARTED"
       
       def __init__(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString):
         self.id=id          self.id=id
         self.title=title          self.title=title
         self.ImageStoragePath=ImageStoragePath          self.ImageStoragePath=ImageStoragePath
         self.ImageViewerPath=ImageViewerPath          self.ImageViewerPath=ImageViewerPath
           self.defaultMetaString=defaultMetaString
   
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+(
         {'label':'Main Config','action':'ImageCollection_config'},          {'label':'Main Config','action':'ImageCollection_config'},
         {'label':'Import','action':'ImportFiles'},          {'label':'Import','action':'ImportFiles'},
           {'label':'Recalculate Metadata','action':'recalculateMeta'},
           {'label':'Import Metadata','action':'importMetaForm'},
           {'label':'Rescale thumbs','action':'scaleThumbs'},
           {'label':'Weight (ECHO)','action':'weightForm'},
         )          )
   
       def weightForm(self):
           """Weight"""
           pt=PageTemplateFile('Products/ImageArchive/zpt/changeWeight.zpt').__of__(self)
           return pt()
   
       def changeWeight(self,weight,RESPONSE=None):
           """Change weight"""
           self.weight=weight
           
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
           
       def importMetaForm(self):
           """import metadata"""
           pt=PageTemplateFile('Products/ImageArchive/zpt/importMeta.zpt').__of__(self)
           return pt()
   
       def importMeta(self,fileupload,tag):
           """import"""
           filedata=fileupload.read()
           dom=xml.dom.minidom.parseString(filedata)
           rows=dom.getElementsByTagName(tag)
           #print "ROWS",rows
           request=self.REQUEST
           for row in rows:
               
               for a in self.leiden_meta_fields:
                   self.REQUEST[a]=getText(row.getElementsByTagName(a)[0].childNodes)
   
               image_id=self.REQUEST['image_id']
               if (not hasattr(self,image_id)) & (not image_id==""):
                   #print image_id
                   newObj=ImageCollection(str(image_id),image_id,'','','')
                   self._setObject(str(image_id),newObj)
   
               id="leiden_meta_data_file"
               self.REQUEST['id']=id
               #objectType=getattr(self.Control_Panel.Products.ImageMetaData,self.genericMetaDataType)
               #objectCreate=objectType.createInObjectManager(id,request)
               #href="http://localhost:8080/tests/testcollection/manage_addProduct/ImageMetaData/leiden_meta_factory/"
               try:
                   addID=getattr(self,image_id)
                   objectCreate=addID.manage_addProduct['ImageMetaData'].leiden_meta_add(id)
                   #getattr(self,image_id)._setObject(id,objectCreate)
                   obj=getattr(addID,id)
                   obj.propertysheets.meta.manage_editProperties(request)
               except:
                   """nothing"""
           return "OK"
       
   
       def nextImage(self,request,selected=None):
           """show nextimage"""
           try:
               ids=self.show_thumbs()
               if request.SESSION.has_key("filename"):
                   filename=request.SESSION["filename"]
                   try:
                       nr=ids.index(filename)
                   except:
                       nr=0
               else:
                   nr=0
   
               if nr==len(ids)-1:
                   return ""
               else:
                   if selected:
                       return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr+1]+"\" target=\"_top\">next image</a>"
                   else:
                       return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr+1]+"\" target=\"_top\">next image</a>"
           except:
               return ""
           
       def prevImage(self,request,selected=None):
           """show nextimage"""
           #return self.getId()
           try:
               ids=self.show_thumbs()
               if request.SESSION.has_key("filename"):
                   filename=request.SESSION["filename"]
                   try:
                       nr=ids.index(filename)
                   except:
                       nr=0
               else:
                   nr=0
   
               if nr==0:
                   return ""
               else:
                   if selected:
                       return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr-1]+"\" target=\"_top\">previous image</a>"
                   else:
                       return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr-1]+"\" target=\"_top\">previous image</a>"
           except:
               return ""
           
       def meta_default(self,filename):
           """url der metadaten"""
           return self.defaultMetaString % filename
                        
       def getThumbAttribute(self,id,attr):
           if hasattr(self,id):
               return getattr(getattr(self,id),attr)
           else:
               if attr=='title':
                   return "<b>Missing Image:%s</b>" % id
   
       def getThumbFunction(self,id,attr):
           #return "DUMP"
           if hasattr(self,id):
               return getattr(getattr(self,id),attr)()
           
               
     def xmlinput(self,url):      def xmlinput(self,url):
         """Anzeige von ausgewaehlten thumbs"""          """Anzeige von ausgewaehlten thumbs"""
         #return url          #return url
         xmldoc=urllib.urlopen(url).read()  
                   
           url=urllib.unquote(url)
           xmldoc=urllib.urlopen(url).read()
           #print url
         dom=xml.dom.minidom.parseString(xmldoc)          dom=xml.dom.minidom.parseString(xmldoc)
                   
         images=dom.getElementsByTagName('imagename')          images=dom.getElementsByTagName('imagename')
Line 116  class ImageCollection(Folder, Persistent Line 302  class ImageCollection(Folder, Persistent
             text=getText(image.childNodes)              text=getText(image.childNodes)
             if not text=="":              if not text=="":
                 rc.append(str(text))                  rc.append(str(text))
           rc.sort()
         self.REQUEST.SESSION['filenames']=rc          self.REQUEST.SESSION['filenames']=rc
         pt=PageTemplateFile('Products/ImageArchive/overview_selected.zpt').__of__(self)          pt=PageTemplateFile('Products/ImageArchive/zpt/overview_selected.zpt').__of__(self)
         return pt()                  return pt()        
   
       def recalculateMeta(self):
           """recalculate the metadata"""
           
           for entryid in self.__dict__:
               entry=getattr(self,entryid)
               if hasattr(entry,'meta_type'):
                   
                   if entry.meta_type=="ImageDigilib":
                       entry.meta=entry.meta_default(entry.getId())
           return "OK"
           
     def addImage(self):      def addImage(self):
         """Add an Image"""          """Add an Image"""
         pt=PageTemplateFile('Products/ImageArchive/addImage.zpt').__of__(self)          pt=PageTemplateFile('Products/ImageArchive/zpt/addImage.zpt').__of__(self)
         return pt()          return pt()
           
     def addImage2(self,fileupload,RESPONSE=None):      def addImage2(self,fileupload,meta,use_default=None,RESPONSE=None):
         """Add"""          """Add"""
         #print "FU",fileupload          #print "FU",fileupload
         manage_AddImageDigilib(self,fileupload.filename,fileupload)  
           if use_default:
               try:
                   meta=self.meta_default(fileupload.filename)
               except:
                   meta=None
           else:
               meta=None
                   
           manage_AddImageDigilib(self,fileupload.filename,fileupload,meta=meta)
         return RESPONSE.redirect(self.REQUEST['URL1']+'/'+fileupload.filename)          return RESPONSE.redirect(self.REQUEST['URL1']+'/'+fileupload.filename)
         #return  self.REQUEST['URL1']+'/'+fileupload.filename          #return  self.REQUEST['URL1']+'/'+fileupload.filename
           
       def ImportFiles2(self,RESPONSE=None):
           """Import the existing files of a folder"""
           files=os.listdir(self.ImageStoragePath)
           ret=""
           #print self.__dict__
           for file in files:
               if not file[0]==".":
                   if self.__dict__.has_key(file):
   
                       ret=ret+"<br>"+file+" already exists!"
                   else:
                       ret=ret+"<br>"+file+" created!"
                       meta=self.meta_default(file)
                       newObj=ImageDigilib(file,file,meta)
                       #print newObj,file
                       #print newObj
                       self._setObject(file,newObj)
           #print ret
           #pt=PageTemplateFile('Products/ImageArchive/out.zpt').__of__(self)
           #print self.ImageStoragePath
           os.popen("ssh nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat.pl %s /mpiwg/temp/online/scaled/small 100 &"% self.ImageViewerPath)
           RESPONSE.redirect('manage_main')
       
     def ImportFiles(self,RESPONSE=None):      def ImportFiles(self,RESPONSE=None):
         """Import the existing files of a folder"""          """Import the existing files of a folder"""
         files=os.listdir(self.ImageStoragePath)          files=os.listdir(self.ImageStoragePath)
         ret=""          ret=""
         #print self.__dict__          #print self.__dict__
         for file in files:          for file in files:
               if not file[0]==".":
             if self.__dict__.has_key(file):              if self.__dict__.has_key(file):
                                   
                 ret=ret+"<br>"+file+" already exists!"                  ret=ret+"<br>"+file+" already exists!"
Line 148  class ImageCollection(Folder, Persistent Line 377  class ImageCollection(Folder, Persistent
                 newObj=ImageDigilib(file,file)                  newObj=ImageDigilib(file,file)
                 #print newObj,file                  #print newObj,file
                 #print newObj                  #print newObj
                       try:
                 self._setObject(file,newObj)                  self._setObject(file,newObj)
                       except:
                           """nothing yet"""
         #print ret          #print ret
         pt=PageTemplateFile('Products/ImageArchive/out.zpt',ret).__of__(self)          #pt=PageTemplateFile('Products/ImageArchive/out.zpt').__of__(self)
           #print self.ImageStoragePath
           os.popen("ssh nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat.pl %s /mpiwg/temp/online/scaled/small 100 &"% self.ImageViewerPath)
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
                   
     def ImageCollection_config(self):      def ImageCollection_config(self):
         """Nothing yet"""          """Nothing yet"""
         pt=PageTemplateFile('Products/ImageArchive/ChangeImageCollectionForm.zpt').__of__(self)          if not hasattr(self,'defaultMetaString'):
               self.defaultMetaString=""
               
           pt=PageTemplateFile('Products/ImageArchive/zpt/ChangeImageCollectionForm.zpt').__of__(self)
         return pt()          return pt()
   
     def ChangeImageCollection(self,title,ImageStoragePath,ImageViewerPath,RESPONSE=None):      def ChangeImageCollection(self,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
         """Change"""          """Change"""
         self.title=title          self.title=title
         self.ImageStoragePath=ImageStoragePath          self.ImageStoragePath=ImageStoragePath
         self.ImageViewerPath=ImageViewerPath          self.ImageViewerPath=ImageViewerPath
           self.defaultMetaString=defaultMetaString
   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
Line 178  class ImageCollection(Folder, Persistent Line 416  class ImageCollection(Folder, Persistent
             #print entry              #print entry
             if hasattr(getattr(self,entry),'thumb'):              if hasattr(getattr(self,entry),'thumb'):
                 ids.append(entry)                  ids.append(entry)
                   
         #print ids          #print ids
           ids.sort()
         return ids          return ids
   
       def firstSets(self,selected=None):
           ids=self.show_thumbs()
           if ids:
               if selected:
                   return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[0]+"\" target=\"_top\">first sets</a>"
               else:
                   return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[0]+"\" target=\"_top\">first sets</a>"
   
       def lastSets(self,selected=None):
           ids=self.show_thumbs()
           if ids:
               colRows=self.getColTimesRow()
   
               if colRows[1]:
                   nr=len(ids)-colRows[0]*colRows[1]
               else:
                   nr=0
   
               if nr<0:
                   nr=0
   
               if selected:
                   return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">last set</a>"
               else:
                   return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">last sets</a>"
   
           
                   
       def nextSets(self,selected=None):
           """show nextimage"""
           ids=self.show_thumbs()
           colRows=self.getColTimesRow()
           if ids:
               if colRows[1]:
   
                   if self.REQUEST.SESSION.has_key("filename"):
                       filename=self.REQUEST.SESSION["filename"]
                       try:
                           nr=ids.index(filename)+colRows[0]*colRows[1]
                           if nr>=len(ids):
                               nr=len(ids)-1
                       except:
                           nr=0
                   else:
                       nr=0
   
                   if nr==len(ids)-1:
                       return ""
                   else:
                       if selected:
                           return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">next set</a>"
                       else:
                           return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">next set</a>"
   
       def prevSets(self,selected=None):
           
           """show nextimage"""
           #return self.getId()
           ids=self.show_thumbs()
           colRows=self.getColTimesRow()
           if ids:
               if colRows[1]:
                   if self.REQUEST.SESSION.has_key("filename"):
                       filename=self.REQUEST.SESSION["filename"]
                       try:
                           nr=ids.index(filename)-colRows[0]*colRows[1]
                           if nr<0:
                               nr=0
                       except:
                           nr=0
                   else:
                       nr=0
                   try:
                       num=ids.index(filename)
                   except:
                       num=0
   
                   if num==0:
                       return ""
                   else:
                       if selected:
                           return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">previous sets</a>"
                       else:
                           return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">previous sets</a>"
               else:
                   return ""
   
       def showRuler(self,selected=None):
           """show ruler"""
           showall =self.REQUEST.SESSION.get('showall','no')
           if showall=='no':
               ids=self.show_thumbs()
               colRows=self.getColTimesRow()
               num=int(len(ids)/(colRows[0]*colRows[1]))
               a=colRows[0]*colRows[1]
               #print num,num+1
               if num+1>1:
   
                   ret="<b>Show thumbnail group no:</b></br>"
                   for i in range(num+1):
                       if (operator.mod(i,10)==0) and i>0:
                           ret +="<br/>" #alle 10 linebreak einfuegen
                       k=i*a
                       if selected:                
                           href=self.REQUEST['URL1']+"/selection?filename="+ids[k]
                       else:
                           href=self.REQUEST['URL1']+"?filename="+ids[k]
   
                       ret+="""<a href="%s" target="_top">%i</a>&nbsp;&nbsp;"""%(href,i)
   
               else:
                   ret=""
               ret+="""<a href="%s?showall=yes" target="_top">show all</a> """%self.REQUEST['URL1']
           else:
               ret="""<a href="%s?showall=no" target="_top">show groups</a> """%self.REQUEST['URL1']
   
           return ret
       
       def show_thumbs_selected_rows(self,numberOfColumns):
           """Ausgabe anzahl"""
           ids=self.show_selected_thumbs()
           self.REQUEST.SESSION['ids']=ids
           number=int(len(ids)/numberOfColumns)+1
           self.REQUEST.SESSION['number']=range(number)
           return range(number+1)
   
       def setColTimesRowForm(self):
           """form for matrix setting"""
           pt=PageTemplateFile('Products/ImageArchive/zpt/selectColTimesRow.zpt').__of__(self)
           return pt()
   
       def setDone(self):
           """done"""
           
           pt=PageTemplateFile('Products/ImageArchive/zpt/changedColTimesRow.zpt').__of__(self)
           return pt()
   
       def setColTimesRow(self,cols,rows):
           """set coltimes row"""
           RESPONSE=self.REQUEST.RESPONSE
           if not rows:
               rows=None
           if rows=="":
               rows=None
   
           if rows:
               RESPONSE.setCookie("ImageViewerRows",rows)
           RESPONSE.setCookie("ImageViewerCols",cols)
   
           RESPONSE.redirect(self.REQUEST['URL1']+"/setDone")
           
       def getColTimesRow(self,showall='No'):
           """coltimesrow"""
           
           REQUEST=self.REQUEST
           """matrix"""
           if REQUEST.cookies.has_key("ImageViewerRows"):
               
               try:
                   rows=int(REQUEST.cookies["ImageViewerRows"])
               except:
                   rows=6
           else:
               rows=6
               
           if REQUEST.cookies.has_key("ImageViewerCols"):
               #print "COLS",REQUEST.cookies["ImageViewerCols"]
               cols=int(REQUEST.cookies["ImageViewerCols"])
           else:
               cols=2
   
           idsnumber=len(self.show_thumbs())
           if rows:
               if cols*rows >idsnumber:
                   rows=int(idsnumber/cols)+1
   
           #print cols,rows
           if showall=='yes':
               rows=int(idsnumber/cols)+1
               
           return (cols,rows)
                   
           
       def show_thumbs_rows(self,numberOfColumns,numberOfRows=None,startId=None):
           """Ausgabe anzahl"""
   
           idsAll=self.show_thumbs()
           
           if self.REQUEST.SESSION.has_key("filename"):
               filename=self.REQUEST.SESSION["filename"]
               
                   
               try:
                   startId=filename
                   if startId=="":
                       startId=idsAll[0][0:]    
               except:
                   startId=idsAll[0][0:]    
           else:
               startId=idsAll[0][0:]
               
   
           
   
           if numberOfRows:
              
               startPic=idsAll.index(startId)
               try:
                   
                   startPic=idsAll.index(startId)
                   endPic=startPic+numberOfColumns*numberOfRows
                   ids=idsAll[startPic:endPic]
               except:
                   ids=idsAll
           else:
   
               ids=idsAll
   
             
           self.REQUEST.SESSION['ids']=ids
           number=int(len(ids)/numberOfColumns)+1
       
           return range(number+1)
   
       def show_thumbs_columns(self,row,numberOfColumns):
           """Ausgabe einer Liste der Reihe"""
           ids=self.REQUEST.SESSION['ids']
           max=len(ids)
           if (row*numberOfColumns)<max:
               return ids[(row-1)*numberOfColumns:row*numberOfColumns]
           else:
               return ids[(row-1)*numberOfColumns:]
           
       def thumblistSelected_old(self):
           """main template collection"""
           pt=PageTemplateFile('Products/ImageArchive/zpt/thumbselected.zpt').__of__(self)
           return pt()
   
     def thumblistSelected(self):      def thumblistSelected(self):
         """main template collection"""          """main template collection"""
         pt=PageTemplateFile('Products/ImageArchive/thumbselected.zpt').__of__(self)          pt=PageTemplateFile('Products/ImageArchive/zpt/thumbselected2.zpt').__of__(self)
           return pt()
       
       def thumblist_old(self):
           """main template collection"""
           pt=PageTemplateFile('Products/ImageArchive/zpt/thumbs.zpt').__of__(self)
         return pt()          return pt()
   
     def thumblist(self):      def thumblist(self):
         """main template collection"""          """main template collection"""
         pt=PageTemplateFile('Products/ImageArchive/thumbs.zpt').__of__(self)          pt=PageTemplateFile('Products/ImageArchive/zpt/thumb2.zpt').__of__(self)
           return pt()
   
       def thumblistNewWindow(self):
           """Thumbs mit clik neues Fenster oeffnen"""
           pt=PageTemplateFile('Products/ImageArchive/zpt/thumbNewWindow.zpt').__of__(self)
           return pt()
           
   
       def navig_selected_html(self):
           """navigation"""
           #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']
           pt=PageTemplateFile('Products/ImageArchive/zpt/navigation_selected.zpt').__of__(self)
         return pt()          return pt()
   
     def navig_html(self):      def navig_html(self):
         """navigation"""          """navigation"""
         pt=PageTemplateFile('Products/ImageArchive/navigation.zpt').__of__(self)          #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']
           pt=PageTemplateFile('Products/ImageArchive/zpt/navigation.zpt').__of__(self)
         return pt()          return pt()
   
   
       def selection(self):
           """show only selected"""
           if self.REQUEST.has_key('filename'):
               filen=self.REQUEST['filename']
           else:
               filen=""
           self.REQUEST.SESSION['filename']=filen
           pt=PageTemplateFile('Products/ImageArchive/zpt/overview_selected2.zpt').__of__(self)
           return pt()  
           
     def index_html(self):      def index_html(self):
         """main template collection"""          """main template collection"""
         if self.REQUEST.has_key('filename'):          if self.REQUEST.has_key('filename'):
             filen=self.REQUEST['filename']              filen=self.REQUEST['filename']
         else:          else:
             filen=""              filen=""
   
         self.REQUEST.SESSION['filename']=filen          self.REQUEST.SESSION['filename']=filen
         pt=PageTemplateFile('Products/ImageArchive/overview.zpt').__of__(self)          
           if self.REQUEST.has_key('showall'):
   
               self.REQUEST.SESSION['showall']=self.REQUEST.get('showall')
           else:
               self.REQUEST.SESSION['showall']=self.REQUEST.SESSION.get('showall','no')
               
           
           pt=PageTemplateFile('Products/ImageArchive/zpt/overview.zpt').__of__(self)
         return pt()          return pt()
           
 def manage_AddImageCollectionForm(self):  def manage_AddImageCollectionForm(self):
     """Nothing yet"""      """Nothing yet"""
     pt=PageTemplateFile('Products/ImageArchive/AddImageCollectionForm.zpt').__of__(self)      pt=PageTemplateFile('Products/ImageArchive/zpt/AddImageCollectionForm.zpt').__of__(self)
       return pt()
       
   def manage_AddImageCollection(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
       """Add ImageCollection"""
       newObj=ImageCollection(id,title,ImageStoragePath,ImageViewerPath,defaultMetaString)
       self._setObject(id,newObj)
       
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
   
   
   class ImageCollectionIFrame(ImageCollection):
       """Class fuer Collection set als IFrame"""
   
       meta_type="ImageCollectionIFrame"
       label=ImageCollection.title
   
       def getImageTag(self):
           """ hack : method needed by echo_content"""
           return ""
       
       def rotate(self,angle,url,RESPONSE):
       """rotate"""
       
       RESPONSE.redirect("javascript:document.domain='mpg.de';parent.iframe.right.rotation(%i)"%int(angle))
       RESPONSE.redirect(url)
       def request(self):
           """request"""
           return self.REQUEST
           
       def index_html(self):
           """index"""
           if self.REQUEST.has_key('filename'):
               filen=self.REQUEST['filename']
           else:
               filen=""
           self.REQUEST.SESSION['filename']=filen
           
       
           pt=PageTemplateFile('Products/ImageArchive/zpt/IFrameMain.zpt').__of__(self)
           return pt()
   
       def iframe_html(self):
           """iframe"""
           if self.REQUEST.has_key('filename'):
               filen=self.REQUEST['filename']
           else:
               filen=""
           self.REQUEST.response.setCookie('filename',filen)
           pt=PageTemplateFile('Products/ImageArchive/zpt/IFrameOverview.zpt').__of__(self)
           return pt()
   
   
   def manage_AddImageCollectionIFrameForm(self):
       """Nothing yet"""
       pt=PageTemplateFile('Products/ImageArchive/zpt/AddImageCollectionIFrameForm.zpt').__of__(self)
     return pt()      return pt()
           
 def manage_AddImageCollection(self,id,title,ImageStoragePath,ImageViewerPath,RESPONSE=None):  def manage_AddImageCollectionIFrame(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
     """Add ImageCollection"""      """Add ImageCollection"""
     newObj=ImageCollection(id,title,ImageStoragePath,ImageViewerPath)      newObj=ImageCollectionIFrame(id,title,ImageStoragePath,ImageViewerPath,defaultMetaString)
     self._setObject(id,newObj)      self._setObject(id,newObj)
           
     if RESPONSE is not None:      if RESPONSE is not None:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.27

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>