Example #1
0
    def POST(self):
        postdata = web.input(masters='', project_id=0)

        project = models.Project.get(id=postdata.project_id)
        if not project:
            raise web.notfound()

        masters = project.get_ordered_masters()

        self.set_masters(masters)

        self.initialize(project.projectname, masters[0].version,
                        masters[1].version)

        self.call_metapost_all_glyphs(self.get_lft_master())

        instance = models.Instance.create(project_id=project.id)

        for extension in ['-webfont.eot', '-webfont.ttf', '.otf']:
            source = project.get_basename() + extension
            dest_dir = op.join(working_dir(), 'instances')
            if not op.exists(dest_dir):
                os.makedirs(dest_dir)
            dest_file = op.join(dest_dir, '%s%s' % (instance.id, extension))
            try:
                shutil.copy(op.join(working_dir(), 'static', source), dest_file)
            except:
                pass

        return simplejson.dumps({})
Example #2
0
 def get_instancelog(self, version=1, ab_source=None):
     if ab_source:
         return op.join(working_dir(),
                        '%s-%s-%03d.log' % (self.projectname,
                                            ab_source.upper(), version))
     return op.join(working_dir(),
                    '%s.log' % (self.projectname))
Example #3
0
def prepare_master_environment(master):
    for f in os.listdir(working_dir('commons', user='******')):
        filename = working_dir(op.join('commons', f), user='******')
        try:
            shutil.copy2(filename, master.get_fonts_directory())
        except (IOError, OSError):
            raise
    writeGlobalParam(master.project)
Example #4
0
def ufo2mf(master):
    dirnamef1 = working_dir(op.join(master.get_fonts_directory('a'), "glyphs"))
    dirnamef2 = working_dir(op.join(master.get_fonts_directory('b'), "glyphs"))
    dirnamep1 = working_dir(op.join(master.get_fonts_directory(), "glyphs"))
    if not op.exists(dirnamep1):
        os.makedirs(dirnamep1)

    charlist1 = filter(lambda f: fnextension(f) == 'glif', os.listdir(dirnamef1))
    charlist2 = filter(lambda f: fnextension(f) == 'glif', os.listdir(dirnamef2))

    for ch1 in charlist1:
        if ch1 in charlist2:
            fnb, ext = buildfname(ch1)
            glyphA = Glyph.get(idmaster=master.idmaster, fontsource='A', name=fnb)
            glyphB = Glyph.get(idmaster=master.idmaster, fontsource='B', name=fnb)
            xmltomf.xmltomf1(master, glyphA, glyphB)
Example #5
0
    def get_fonts_directory(self, ab_source=None):
        """
        Return uploaded user font project directory.

        If ab_source set then return FontA or FontB directories in fonts
        project directory.

        >>> master = query(Master).filter(idmaster=1).one()
        >>> master.get_fonts_directory()
        /var/www/webpy-app/metapolator/users/1/fonts/1
        >>> master.get_fonts_directory('a')
        /var/www/webpy-app/metapolator/users/1/fonts/1/FontNameA.UFO
        >>> master.get_fonts_directory('b')
        /var/www/webpy-app/metapolator/users/1/fonts/1/FontNameB.UFO

        If FontB is not set then it returns FontA for that

        >>> master = query(Master).filter(idmaster=2).one()
        >>> master.get_fonts_directory()
        /var/www/webpy-app/metapolator/users/1/fonts/1
        >>> master.get_fonts_directory('a')
        /var/www/webpy-app/metapolator/users/1/fonts/1/FontNameA.UFO
        >>> master.get_fonts_directory('b')
        /var/www/webpy-app/metapolator/users/1/fonts/1/FontNameA.UFO
        """
        fonts_directory = op.join(working_dir(), 'fonts', str(self.idmaster))
        if not ab_source:
            return fonts_directory
        if ab_source.lower() == 'a':
            return op.join(fonts_directory, self.fontnamea)
        elif ab_source.lower() == 'b' and self.fontnameb:
            return op.join(fonts_directory, self.fontnameb)
        return op.join(fonts_directory, self.fontnamea)
Example #6
0
    def POST(self, name, glyphid):
        if not is_loggedin():
            return web.notfound()

        master = models.Master.get(fontname=name)
        if not master:
            return web.notfound()

        x = web.input(pointnr='', source='', x='', y='')

        query = models.GlyphOutline.filter(idmaster=master.idmaster,
                                           fontsource=x.source.upper(),
                                           glyphname=glyphid,
                                           pointnr=x.pointnr)
        query.update(dict(x=x.x, y=x.y))
        web.ctx.orm.commit()
        writeGlyphlist(master, glyphid)

        glyphA = models.Glyph.get(idmaster=master.idmaster,
                                  fontsource='A', name=glyphid)
        glyphB = models.Glyph.get(idmaster=master.idmaster,
                                  fontsource='A', name=glyphid)
        import xmltomf
        xmltomf.xmltomf1(master, glyphA, glyphB)
        makefont(working_dir(), master)
        M_glyphjson = get_edges_json(u'%s.log' % master.fontname, glyphid)
        if x.source.upper() == 'A':
            glyphjson = get_edges_json(u'%sA.log' % master.fontname, glyphid)
        else:
            glyphjson = get_edges_json(u'%sB.log' % master.fontname, glyphid)
        return simplejson.dumps({'M': M_glyphjson,
                                 'R': glyphjson})
Example #7
0
def makefont_single(master, cell=''):
    if not project_exists(master):
        return False

    cell = cell.upper()
    os.environ['MFINPUTS'] = master.get_fonts_directory()
    os.environ['MFMODE'] = session.get('mfparser', '')
    if cell == 'A':
        metafont = master.get_metafont('a')
    else:
        metafont = master.get_metafont()

    import subprocess
    process = subprocess.Popen(
        ["sh", "makefont.sh", metafont],
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        cwd=working_dir()
    )

    while True:
        line = process.stdout.readline()
        if not line or '<to be read again>' in line:
            process.kill()
            break
Example #8
0
 def GET(self):
     if not is_loggedin():
         raise seeother('/login')
     mmaster = models.Master.all()
     fontlist = [f for f in glob.glob(working_dir('fonts') + "/*/*.ufo")]
     fontlist.sort()
     form = FontForm()
     return render.font1(fontlist, form, mmaster, cFont)
Example #9
0
def prepare_environment_directory(force=False):
    filelist = ['makefont.sh', 'mf2pt1.mp', 'mf2pt1.pl', 'mf2pt1.texi',
                'mtp.enc']

    static_directory = op.join(working_dir(), 'static')
    if not op.exists(static_directory):
        os.makedirs(static_directory)

    if op.exists(op.join(working_dir(), 'makefont.sh')) and not force:
        return

    for filename in filelist:
        try:
            shutil.copy2(op.join(working_dir(user='******'), filename),
                         op.join(working_dir()))
        except (OSError, IOError):
            raise
Example #10
0
 def get_fonts_directory(master, ab_source=None):
     fonts_directory = op.join(working_dir(), 'fonts', str(master.idmaster))
     if ab_source.lower() == 'a':
         return op.join(fonts_directory, master.FontNameA)
     elif ab_source.lower() == 'b' and master.FontNameB:
         return op.join(fonts_directory, master.FontNameB)
     elif ab_source.lower() == 'b':
         return op.join(fonts_directory, master.FontNameA)
     return fonts_directory
Example #11
0
    def GET(self, id):
        if not is_loggedin():
            raise seeother('/login')
        mmaster = models.Master.all()

        fontname = cFont.fontname
        fontna = cFont.fontna
        fontnb = cFont.fontnb

        fontlist = [f for f in glob.glob(working_dir('fonts') + "/*/*.ufo")]
        fontlist.sort()
        form = FontForm()
        form.fill({'Name': fontname, 'UFO_A': fontna, 'UFO_B': fontnb})

        if id == 'i0':
            cFont.loadoption = 0
            cFont.loadoptionAll = 0
            model.putFont()
            return render.font1(fontlist, form, mmaster, cFont)
        if id == 'i1':
            cFont.loadoption = 1
            cFont.loadoptionAll = 0
            model.putFont()
            return render.font1(fontlist, form, mmaster, cFont)
        if id == 'i2':
            cFont.loadoption = 0
            cFont.loadoptionAll = 1
            putFontAllglyphs()
            return render.font1(fontlist, form, mmaster, cFont)
        if id == 'i3':
            cFont.loadoption = 1
            cFont.loadoptionAll = 1
            putFontAllglyphs()
            return render.font1(fontlist, form, mmaster, cFont)
        if id == 'e4':
            mfoption = 0
            model.writexml()
            return render.font1(fontlist, form, mmaster, cFont)
        if id == 'e5':
            mfoption = 1
            alist = list(get_activeglyph())
            writeallxmlfromdb(alist)
            return render.font1(fontlist, form, mmaster, cFont)
        if id == '20000':
            return render.cproject()

        id = int(id)

        if id > 1000 and id < 10000:
            cFont.glyphName = chr(id - 1001 + 32)
            cFont.glyphunic = str(id - 1001)

        master = None
        if id > 0 and id < 1000:
            master = models.Master.get(idmaster=id)

        return render.font1(fontlist, form, mmaster, cFont, master)
Example #12
0
def copyproject():
    idmaster = int(cFont.idmaster)
    #
    # copy unix font ufo files
    #
    # mkdir -p fonts/3
    # cp -rpu fonts/1/* fonts/3/
    #
    idma = Master.select_maxid(session.user)
    idmasternew = idma[0].maxid + 1
    print "idmasternew", idmasternew
    #
    import shutil
    new_proj_dir = working_dir(op.join('fonts', str(idmasternew)))
    old_proj_dir = working_dir(op.join('fonts', str(idmaster)))
    shutil.copytree(old_proj_dir, new_proj_dir)
    #
    #
    for iloop in [1, -1]:
        idmnew = "'"+str(iloop*idmasternew)+"'"
        idm = "'"+str(iloop*idmaster)+"'"
        strg = ("insert into master (idmaster,FontName,FontNameA,FontNameB,idglobal,vdate,user_id)"
                " select "+idmnew+", FontName,FontNameA,FontNameB,idglobal,now(),user_id from master where"
                " user_id=%s and idmaster=%s") % (session.user, idm)
        print strg
        db.query(strg)

        strg = ("insert into glyphoutline (idmaster,id,glyphname,PointNr,x,y,contrp,pip,vdate,user_id)"
                " select "+idmnew+",id,glyphname,PointNr,x,y,contrp,pip,now(),user_id from glyphoutline where"
                " user_id=%s and idmaster=%s") % (session.user, idm)
        print strg
        db.query(strg)

        strg = ("insert into groupparam (idmaster,user_id,groupname,vdate,startp,doubledash,tripledash,superleft,superright,leftp,rightp,downp,upp,dir,leftp2,rightp2,downp2,upp2,dir2,tension,tensionand,cycle,penshifted,pointshifted,angle,penwidth,overx,overbase,overcap,overasc,overdesc,ascpoint,descpoint,stemcutter,stemshift,inktrap_l,inktrap_r)"
                " select "+idmnew+",user_id,groupname,now(),startp,doubledash,tripledash,superleft,superright,leftp,rightp,downp,upp,dir,leftp2,rightp2,downp2,upp2,dir2,tension,tensionand,cycle,penshifted,pointshifted,angle,penwidth,overx,overbase,overcap,overasc,overdesc,ascpoint,descpoint,stemcutter,stemshift,inktrap_l,inktrap_r from groupparam where"
                " user_id=%s and idmaster=%s") % (session.user, idm)
        print strg
        db.query(strg)
        strg = ("insert into glyphparam (idmaster,id,glyphname,user_id,PointName,groupname,vdate,startp,doubledash,tripledash,superleft,superright,leftp,rightp,downp,upp,dir,leftp2,rightp2,downp2,upp2,dir2,tension,tensionand,cycle,penshifted,pointshifted,angle,penwidth,overx,overbase,overcap,overasc,overdesc,ascpoint,descpoint,stemcutter,stemshift,inktrap_l,inktrap_r)"
                " select "+idmnew+",id,glyphname,user_id,PointName,groupname,now(),startp,doubledash,tripledash,superleft,superright,leftp,rightp,downp,upp,dir,leftp2,rightp2,downp2,upp2,dir2,tension,tensionand,cycle,penshifted,pointshifted,angle,penwidth,overx,overbase,overcap,overasc,overdesc,ascpoint,descpoint,stemcutter,stemshift,inktrap_l,inktrap_r from glyphparam where"
                " user_id=%s and idmaster=%s") % (session.user, idm)
        print strg
        db.query(strg)
        return
Example #13
0
    def GET(self, id):
        master = models.Master.get(idmaster=id)
        if not master:
            return web.notfound()

        prepare_environment_directory()

        putFontAllglyphs(master)
        makefont(working_dir(), master)
        raise seeother('/fonts/')
Example #14
0
def get_edges_json(log_filename, glyphid=None):
    result = {'edges': []}
    try:
        fp = open(op.join(working_dir(), log_filename))
        content = fp.read()
        fp.close()
        return get_json(content, glyphid)
    except (IOError, OSError):
        pass
    return result
Example #15
0
def writeGlyphlist(master, glyphid=None):
    ifile = open(op.join(master.get_fonts_directory(), "glyphlist.mf"), "w")
    dirnamep1 = working_dir(op.join(master.get_fonts_directory(), "glyphs"))

    charlist1 = [f for f in os.listdir(dirnamep1)]

    for ch1 in charlist1:
        fnb, ext = buildfname(ch1)
        if (not glyphid or str(glyphid) == fnb) and ext in ["mf"]:
            ifile.write("input glyphs/" + ch1 + "\n")
    ifile.close()
Example #16
0
    def POST(self, name, glyphid):
        if not is_loggedin():
            raise seeother('/login')

        master = models.Master.get(fontname=name)
        if not master:
            return web.notfound()

        x = web.input(idlocal_changed=False, idglobal_changed=False,
                      ab_source='a')

        form = LocalParamForm()
        if x.idlocal_changed:
            # if dropdown value in form has been changed so just refresh
            # data in selected form
            attrs = Settings.get_local_params(x.idlocal_changed, x.ab_source)
            return simplejson.dumps(attrs)
        elif x.idglobal_changed:
            params = models.GlobalParam.get(idglobal=x.idglobal_changed)
            return simplejson.dumps(params.as_dict())

        if 'ab_source' in form.d and form.validates():
            idlocal = form.d.idlocal
            fontsource = form.d.ab_source
            models.Master.update(idmaster=master.idmaster,
                                 values={'idlocal{0}'.format(fontsource.lower()): idlocal})
            master = models.Master.get(fontname=name)

            values = form.d
            del values['ab_source']
            del values['save']
            del values['idlocal']

            models.LocalParam.update(idlocal=idlocal, values=values)

        formg = GlobalParamForm()
        if formg.validates():
            idglobal = formg.d.idglobal
            models.Master.update(idmaster=master.idmaster,
                                 values={'idglobal': idglobal})
            master = models.Master.get(fontname=name)

            values = formg.d
            del values['idglobal']
            del values['save']

            models.GlobalParam.update(idglobal=idglobal, values=values)

        writeGlyphlist(master, glyphid)
        if model.writeGlobalParam(master):
            makefont(working_dir(), master)
        raise seeother('/view/{0}/{1}/settings/'.format(master.fontname, glyphid))
Example #17
0
    def POST(self, id):
        if not is_loggedin():
            raise seeother('/login')
        mmaster = list(model.get_masters())
        form = FontForm()
        form.fill()
        cFont.fontname = form.d.Name
        cFont.fontna = form.d.UFO_A
        cFont.fontnb = form.d.UFO_B
        #
        fontlist = [f for f in glob.glob(working_dir('fonts') + "/*/*.ufo")]
        fontlist.sort()

        return render.font1(fontlist, form, mmaster, cFont)
Example #18
0
def writexml(master, ab_source=None):
#
#  write  two xml file for glyph in A and B Font
#

    glyphName = cFont.glyphunic
    idworks = cFont.idwork

    idmaster = gidmast(cFont.idwork)

    if cFont.idwork == '0':
        glyphsourceA = op.join(working_dir(cFont.fontpath), cFont.fontna,
                               "glyphs", glyphName + ".glif")
        glyphsource = glyphsourceA
        try:
            xmldoc = etree.parse(glyphsourceA)
        except IOError:
            return
        items = xmldoc.find("outline")

    if cFont.idwork == '1':
        glyphsourceB = op.join(working_dir(cFont.fontpath), cFont.fontnb,
                               "glyphs", glyphName + ".glif")
        glyphsource = glyphsourceB
        try:
            xmldoc = etree.parse(glyphsourceB)
        except IOError:
            return
        items = xmldoc.find("outline")

    ids = " and idmaster="+'"'+str(idmaster)+'"'
    inum = 0
    #   db_rows=list(db.query("SELECT PointName,x,y from glyphoutline"))
    #   we assume the number of rows from the db >= the number of the itemlist
    for itemlist in items:
        for s in itemlist:
            inum = inum + 1

            db_row = VDBGlyphOutline.select_one(session.user, inum, glyphName, idmaster)
            if not db_row:
                continue
            s.attrib['pointNo'] = str(db_row.PointNr)
            s.attrib['x'] = str(db_row.x)
            s.attrib['y'] = str(db_row.y)
            sname = db_row.PointName

            if not sname:
                if s.get('name'):
                    del s.attrib['name']
                continue

            db_rowpar = VDBGlyphOutlines.select_one(session.user, inum, glyphName, idmaster)
            nameattr = sname
            if s.get('name'):
                s.attrib['name'] = nameattr
            else:
                s.attrib['name'] = nameattr
            #
            # first read group parameters
            if str(db_rowpar.groupn) not in ["None", 'NULL', '']:
                groupname = db_rowpar.groupn
                #     save the groupname in an xml attribute
                #
                if s.get('groupname'):
                    s.attrib['groupname'] = groupname
                else:
                    s.sattrib('groupname', groupname)
                #
                #     get the parameter list included with group parameters (lower priority)
                db_rowpar = VGLS.select_one(session.user, inum, glyphName, idmaster)

            #
            # read param value and write into xml
            # add glyphparameters here:
            xxmlat(s, db_rowpar.startp, 'startp', '1', 0)
            xxmlat(s, db_rowpar.doubledash, 'doubledash', '1', 0)
            xxmlat(s, db_rowpar.tripledash, 'tripledash', '1', 0)
            xxmlat(s, db_rowpar.superleft, 'superleft', '', 5)
            xxmlat(s, db_rowpar.superright, 'superright', '', 5)
            xxmlat(s, db_rowpar.leftp, 'leftp', '1', 0)
            xxmlat(s, db_rowpar.rightp, 'rightp', '1', 0)
            xxmlat(s, db_rowpar.downp, 'downp', '1', 0)
            xxmlat(s, db_rowpar.upp, 'upp', '1', 0)
            xxmlat(s, db_rowpar.dir, 'dir', '', 0)
            xxmlat(s, db_rowpar.leftp2, 'leftp2', '1', 0)
            xxmlat(s, db_rowpar.rightp2, 'rightp2', '1', 0)
            xxmlat(s, db_rowpar.downp2, 'downp2', '1', 0)
            xxmlat(s, db_rowpar.upp2, 'upp2', '1', 0)
            xxmlat(s, db_rowpar.dir2, 'dir2', '', 0)
            xxmlat(s, db_rowpar.tension, 'tension', '', 0)
            xxmlat(s, db_rowpar.tensionand, 'tensionand', '', 0)
            xxmlat(s, db_rowpar.cycle, 'cycle', '', 0)
            xxmlat(s, db_rowpar.penshifted, 'penshifted', '', 0)
            xxmlat(s, db_rowpar.pointshifted, 'pointshifted', '', 0)
            xxmlat(s, db_rowpar.angle, 'angle', '', 0)
            xxmlat(s, db_rowpar.penwidth, 'penwidth', '', 0)
            xxmlat(s, db_rowpar.overx, 'overx', '', 0)
            xxmlat(s, db_rowpar.overbase, 'overbase', '', 0)
            xxmlat(s, db_rowpar.overcap, 'overcap', '', 0)
            xxmlat(s, db_rowpar.overasc, 'overasc', '', 0)
            xxmlat(s, db_rowpar.ascpoint, 'ascpoint', '1', 0)
            xxmlat(s, db_rowpar.descpoint, 'descpoint', '1', 0)
            xxmlat(s, db_rowpar.stemcutter, 'stemcutter', '', 4)
            xxmlat(s, db_rowpar.stemshift, 'stemshift', '', 4)
            xxmlat(s, db_rowpar.inktrap_l, 'inktrap_l', '', 4)
            xxmlat(s, db_rowpar.inktrap_r, 'inktrap_r', '', 4)
#

    print "glyphsource", glyphsource
    with codecs.open(glyphsource, "w", "utf-8") as out:
        xmldoc.write(out)
    out.close()
#  restore current idwork setting
    cFont.idwork = idworks
Example #19
0
    def POST(self):
        if not is_loggedin():
            raise seeother('/login')

        x = web.input(zipfile={})
        if 'name' in x and models.Master.exists(fontname=x.name):
            return render.create_project(error='Project with this name already exists')

        if 'zipfile' in x and 'name' in x and x.name:
            filename = op.join(working_dir(), x.zipfile.filename)

            try:
                with open(filename, 'w') as fp:
                    fp.write(x.zipfile.file.read())
            except (IOError, OSError):
                return render.create_project(error='Could not upload this file to disk')

            prepare_environment_directory()

            try:
                fzip = zipfile.ZipFile(filename)

                namelist = fzip.namelist()

                iscorrect_ufo = False
                ufo_dirs = []
                for f in namelist:
                    if re.search(r'.ufo[\\/]$', f):
                        ufo_dirs.append(re.sub(r'[\\/]', '', f))
                    if re.search(r'.ufo[\\/]glyphs[\\/].*?.glif$', f, re.IGNORECASE):
                        iscorrect_ufo = True

                if not iscorrect_ufo:
                    return render.create_project(error='Archive does not contain any correct UFO folder')

                FontNameA = ufo_dirs[0]
                try:
                    FontNameB = ufo_dirs[1]
                except IndexError:
                    FontNameB = ''
                master = models.Master.create(fontname=x.name)

                fontpath = master.get_fonts_directory()
                fzip.extractall(fontpath)

                shutil.move(op.join(fontpath, FontNameA),
                            op.join(fontpath, '%sA.UFO' % x.name))
                if FontNameB:
                    shutil.move(op.join(fontpath, FontNameB),
                                op.join(fontpath, '%sB.UFO' % x.name))
                    FontNameB = '%sB.UFO' % x.name

                models.Master.update(idmaster=master.idmaster,
                                     values=dict(fontnamea='%sA.UFO' % x.name,
                                                 fontnameb=FontNameB))

                FontNameA = '%sA.UFO' % x.name
                if not FontNameB:
                    FontNameB = '%sB.UFO' % x.name
                for f in os.listdir(working_dir('commons', user='******')):
                    filename = working_dir(op.join('commons', f),
                                           user='******')
                    try:
                        if filename.endswith('font.mf'):
                            shutil.copy2(filename, op.join(fontpath, mf_filename(FontNameA)))
                            shutil.copy2(filename, op.join(fontpath, mf_filename(FontNameB)))
                            shutil.copy2(filename, op.join(fontpath, mf_filename(x.name)))
                        else:
                            shutil.copy2(filename, fontpath)
                    except (IOError, OSError):
                        raise

                putFontAllglyphs(master)
                writeGlyphlist(master)
                makefont(working_dir(), master)
            except (zipfile.BadZipfile, OSError, IOError):
                if master:
                    models.Master.delete(idmaster=master.idmaster)
                    models.GlyphOutline.delete(idmaster=master.idmaster)
                    models.GlyphParam.delete(idmaster=master.idmaster)

                    fontpath = master.get_fonts_directory()
                    shutil.rmtree(fontpath)
            return seeother('/fonts/')

        return render.create_project(error='Please fill all fields in form')
Example #20
0
 def get_directory(self, version=1):
     directory = op.join(working_dir(), '%s-%03d' % (self.projectname,
                                                     version))
     if not op.exists(directory):
         os.makedirs(directory)
     return directory