axis.py

CNC 的开放码,EMC2 V2.2.8版

        glMatrixMode(GL_PROJECTION)
        glPushMatrix()
        glLoadIdentity()
        vport = glGetIntegerv(GL_VIEWPORT)
        gluPickMatrix(event.x, vport[3]-event.y, 5, 5, vport)
        glMultMatrixd(pmatrix)
        glMatrixMode(GL_MODELVIEW)

        while 1:
            glSelectBuffer(self.select_buffer_size)
            glRenderMode(GL_SELECT)
            glInitNames()
            glPushName(0)

            glCallList(select_program)

            try:
                buffer = list(glRenderMode(GL_RENDER))
            except GLerror, detail:
                if detail.errno[0] == GL_STACK_OVERFLOW:
                    self.select_buffer_size *= 2
                    continue
                raise
            break

        buffer.sort()

        if buffer:
            min_depth, max_depth, names = buffer[0]
            self.set_highlight_line(names[0])
        else:
            self.set_highlight_line(None)

        glMatrixMode(GL_PROJECTION)
        glPopMatrix()
        glMatrixMode(GL_MODELVIEW)

    def set_current_line(self, line):
        if line == vars.running_line.get(): return
        t.tag_remove("executing", "0.0", "end")
        if line is not None and line > 0:
            vupdate(vars.running_line, line)
            if vars.highlight_line.get() <= 0:
                t.see("%d.0" % (line+2))
                t.see("%d.0" % line)
            t.tag_add("executing", "%d.0" % line, "%d.end" % line)
        else:
            vupdate(vars.running_line, 0)

    def set_highlight_line(self, line):
        if line == vars.highlight_line.get(): return
        self.highlight_line = line
        t.tag_remove("sel", "0.0", "end")
        if line is not None and line > 0:
            t.see("%d.0" % (line+2))
            t.see("%d.0" % line)
            t.tag_add("sel", "%d.0" % line, "%d.end" % line)
            vupdate(vars.highlight_line, line)
        else:
            vupdate(vars.highlight_line, -1)
        global highlight
        if highlight is not None: glDeleteLists(highlight, 1)
        highlight = glGenLists(1)
        glNewList(highlight, GL_COMPILE)
        if line is not None and self.g is not None:
            x, y, z = self.g.highlight(line)
            self.set_centerpoint(x, y, z)
        elif self.g is not None:
            x = (self.g.min_extents[0] + self.g.max_extents[0])/2
            y = (self.g.min_extents[1] + self.g.max_extents[1])/2
            z = (self.g.min_extents[2] + self.g.max_extents[2])/2
            self.set_centerpoint(x, y, z)
        glEndList()
 
    def zoomin(self, event):
        self.distance = self.distance / 1.25
        self.tkRedraw()

    def zoomout(self, event):
        self.distance = self.distance * 1.25
        self.tkRedraw()

    def zoomwheel(self, event):
        if event.delta > 0: self.zoomin(event)
        else: self.zoomout(event)

    def tkRedraw(self, *dummy):
        if self.after_id:
            # May need to upgrade to an instant redraw
            self.after_cancel(self.after_id)
        self.after_id = self.after_idle(self.actual_tkRedraw)

    def redraw_soon(self, *dummy):
        if self.after_id: return
        self.after_id = self.after(50, self.actual_tkRedraw)

    def tkRedraw_perspective(self, *dummy):
        """Cause the opengl widget to redraw itself."""

        if not self.initialised: return
        self.activate()

        glPushMatrix()                  # Protect our matrix
        self.update_idletasks()
        self.activate()
        w = self.winfo_width()
        h = self.winfo_height()
        glViewport(0, 0, w, h)

        # Clear the background and depth buffer.
        glClearColor(*(self.colors['back'] + (0,)))
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

        glMatrixMode(GL_PROJECTION)
        glLoadIdentity()
        gluPerspective(self.fovy, float(w)/float(h), self.near, self.far + self.distance)

        gluLookAt(0, 0, self.distance,
            0, 0, 0,
            0., 1., 0.)
        glMatrixMode(GL_MODELVIEW)

        # Call objects redraw method.
        self.redraw()
        glFlush()                               # Tidy up
        glPopMatrix()                   # Restore the matrix

        self.tk.call(self._w, 'swapbuffers')

    def tkRedraw_ortho(self, *dummy):
        """Cause the opengl widget to redraw itself."""

        if not self.initialised: return
        self.activate()

        glPushMatrix()                  # Protect our matrix
        self.update_idletasks()
        self.activate()
        w = self.winfo_width()
        h = self.winfo_height()
        glViewport(0, 0, w, h)

        # Clear the background and depth buffer.
        glClearColor(*(self.colors['back'] + (0,)))
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

        glMatrixMode(GL_PROJECTION)
        glLoadIdentity()
        ztran = self.distance
        k = sqrt(abs(ztran or 1))
        l = k * h / w
        glOrtho(-k, k, -l, l, -1000, 1000.)

        gluLookAt(0, 0, 1,
            0, 0, 0,
            0., 1., 0.)
        glMatrixMode(GL_MODELVIEW)

        # Call objects redraw method.
        self.redraw()
        glFlush()                               # Tidy up
        glPopMatrix()                   # Restore the matrix

        self.tk.call(self._w, 'swapbuffers')

    def startRotate(self, event):
        if lathe: return
        return Opengl.startRotate(self, event)

    def tkAutoSpin(self, event):
        if lathe: return
        return Opengl.tkAutoSpin(self, event)

    def tkRotate(self, event):
        if lathe: return
        Opengl.tkRotate(self, event)
        self.perspective = True
        widgets.view_z.configure(relief="link")
        widgets.view_z2.configure(relief="link")
        widgets.view_x.configure(relief="link")
        widgets.view_y.configure(relief="link")
        widgets.view_p.configure(relief="link")
        vars.view_type.set(0)

    def actual_tkRedraw(self, *dummy):
        self.after_id = None
        if self.perspective:
            self.tkRedraw_perspective()
        else:
            self.tkRedraw_ortho()

    def set_eyepoint_from_extents(self, e1, e2):
        w = self.winfo_width()
        h = self.winfo_height()

        ztran = max(2.0, e1, e2 * w/h) ** 2
        self.set_eyepoint(ztran - self.zcenter)


    def redraw(self):
        if self.select_event:
            self.select(self.select_event)
            self.select_event = None

        glDisable(GL_LIGHTING)
        glMatrixMode(GL_MODELVIEW)

        if vars.show_program.get() and program is not None:
            glCallList(program)
            if highlight is not None: glCallList(highlight)

            if vars.show_extents.get():
                # Dimensions
                x,y,z,p = 0,1,2,3
                if str(widgets.view_x['relief']) == "sunken":
                    view = x
                elif str(widgets.view_y['relief']) == "sunken":
                    view = y
                elif (str(widgets.view_z['relief']) == "sunken" or
                      str(widgets.view_z2['relief']) == "sunken"):
                    view = z
                else:
                    view = p

                g = self.g

                dimscale = vars.metric.get() and 25.4 or 1.0
                fmt = vars.metric.get() and "%.1f" or "%.2f"

                pullback = max(g.max_extents[x] - g.min_extents[x],
                               g.max_extents[y] - g.min_extents[y],
                               g.max_extents[z] - g.min_extents[z],
                               2 ) * .1

                dashwidth = pullback/4
                charsize = dashwidth * 1.5
                halfchar = charsize * .5

                if view == z or view == p:
                    z_pos = g.min_extents[z]
                    zdashwidth = 0
                else:
                    z_pos = g.min_extents[z] - pullback
                    zdashwidth = dashwidth
                # x dimension

                color_limit(0)
                glBegin(GL_LINES)
                if view != x and g.max_extents[x] > g.min_extents[x]:
                    y_pos = g.min_extents[y] - pullback;
                    glVertex3f(g.min_extents[x], y_pos, z_pos)
                    glVertex3f(g.max_extents[x], y_pos, z_pos)

                    glVertex3f(g.min_extents[x], y_pos - dashwidth, z_pos - zdashwidth)
                    glVertex3f(g.min_extents[x], y_pos + dashwidth, z_pos + zdashwidth)

                    glVertex3f(g.max_extents[x], y_pos - dashwidth, z_pos - zdashwidth)
                    glVertex3f(g.max_extents[x], y_pos + dashwidth, z_pos + zdashwidth)

                # y dimension
                if view != y and g.max_extents[y] > g.min_extents[y]:
                    x_pos = g.min_extents[x] - pullback;
                    glVertex3f(x_pos, g.min_extents[y], z_pos)
                    glVertex3f(x_pos, g.max_extents[y], z_pos)

                    glVertex3f(x_pos - dashwidth, g.min_extents[y], z_pos - zdashwidth)
                    glVertex3f(x_pos + dashwidth, g.min_extents[y], z_pos + zdashwidth)

                    glVertex3f(x_pos - dashwidth, g.max_extents[y], z_pos - zdashwidth)
                    glVertex3f(x_pos + dashwidth, g.max_extents[y], z_pos + zdashwidth)

                # z dimension
                if view != z and g.max_extents[z] > g.min_extents[z]:
                    x_pos = g.min_extents[x] - pullback;
                    y_pos = g.min_extents[y] - pullback;
                    glVertex3f(x_pos, y_pos, g.min_extents[z]);
                    glVertex3f(x_pos, y_pos, g.max_extents[z]);

                    glVertex3f(x_pos - dashwidth, y_pos - zdashwidth, g.min_extents[z])
                    glVertex3f(x_pos + dashwidth, y_pos + zdashwidth, g.min_extents[z])

                    glVertex3f(x_pos - dashwidth, y_pos - zdashwidth, g.max_extents[z])
                    glVertex3f(x_pos + dashwidth, y_pos + zdashwidth, g.max_extents[z])

                glEnd()

                # Labels
                s.poll()
                if vars.coord_type.get():
                    offset = to_internal_units(s.origin)
                else:
                    offset = 0, 0, 0
                if view != z and g.max_extents[z] > g.min_extents[z]:
                    if view == x:
                        x_pos = g.min_extents[x] - pullback;
                        y_pos = g.min_extents[y] - 6.0*dashwidth;
                    else:
                        x_pos = g.min_extents[x] - 6.0*dashwidth;
                        y_pos = g.min_extents[y] - pullback;

                    bbox = color_limit(g.min_extents[z] < machine_limit_min[z])
                    glPushMatrix()
                    f = fmt % ((g.min_extents[z]-offset[z]) * dimscale)
                    glTranslatef(x_pos, y_pos, g.min_extents[z] - halfchar)
                    glScalef(charsize, charsize, charsize)
                    glRotatef(-90, 0, 1, 0)
                    glRotatef(-90, 0, 0, 1)
                    if view != x:
                        glRotatef(-90, 0, 1, 0)
                    hershey.plot_string(f, 0, bbox)
                    glPopMatrix()

                    bbox = color_limit(g.max_extents[z] > machine_limit_max[z])
                    glPushMatrix()
                    f = fmt % ((g.max_extents[z]-offset[z]) * dimscale)
                    glTranslatef(x_pos, y_pos, g.max_extents[z] - halfchar)
                    glScalef(charsize, charsize, charsize)
                    glRotatef(-90, 0, 1, 0)
                    glRotatef(-90, 0, 0, 1)
                    if view != x:
                        glRotatef(-90, 0, 1, 0)
                    hershey.plot_string(f, 0, bbox)
                    glPopMatrix()

                    color_limit(0)
                    glPushMatrix()
                    f = fmt % ((g.max_extents[z] - g.min_extents[z]) * dimscale)
                    glTranslatef(x_pos, y_pos, (g.max_extents[z] + g.min_extents[z])/2)
                    glScalef(charsize, charsize, charsize)
                    if view != x:
                        glRotatef(-90, 0, 0, 1)
                    glRotatef(-90, 0, 1, 0)
                    hershey.plot_string(f, .5, bbox)
                    glPopMatrix()

                if view != y and g.max_extents[y] > g.min_extents[y]:
                    x_pos = g.min_extents[x] - 6.0*dashwidth;

                    bbox = color_limit(g.min_extents[y] < machine_limit_min[y])
                    glPushMatrix()
                    f = fmt % ((g.min_extents[y] - offset[y]) * dimscale)
                    glTranslatef(x_pos, g.min_extents[y] + halfchar, z_pos)
                    glRotatef(-90, 0, 0, 1)
                    glRotatef(-90, 0, 0, 1)
                    if view == x:
                        glRotatef(90, 0, 1, 0)
                        glTranslatef(dashwidth*1.5, 0, 0)
                    glScalef(charsize, charsize, charsize)
                    hershey.plot_string(f, 0, bbox)
                    glPopMatrix()

                    bbox = color_limit(g.max_extents[y] > machine_limit_max[y])
                    glPushMatrix()
                    f = fmt % ((g.max_extents[y] - offset[y]) * dimscale)
                    glTranslatef(x_pos, g.max_extents[y] + halfchar, z_pos)
                    glRotatef(-90, 0, 0, 1)
                    glRotatef(-90, 0, 0, 1)
                    if view == x:
                        glRotatef(90, 0, 1, 0)
                        glTranslatef(dashwidth*1.5, 0, 0)
                    glScalef(charsize, charsize, charsize)
                    hershey.plot_string(f, 0, bbox)
                    glPopMatrix()

                    color_limit(0)
                    glPushMatrix()