Example #1
0
    def load_formula(self,file):
        try:
            self.compiler.load_formula_file(file)
            type = browser.guess_type(file)
            browser.set_type(type)
            browser.update(file)
            browser.show(self.window, self.f, type)

            return True
        except Exception, err:
            self.show_error_message(_("Error opening %s") % file, err)
            return False
Example #2
0
 def load(self,file):
     try:
         if fc.FormulaTypes.isFormula(file):
             self.load_formula(file)
             return True
         self.f.loadFctFile(open(file))
         self.update_recent_files(file)
         self.set_filename(file)
         browser.update(self.f.forms[0].funcFile, self.f.forms[0].funcName)
         return True
     except Exception, err:
         self.show_error_message(_("Error opening %s") % file,err)
         return False
Example #3
0
class MainWindow:
    def __init__(self, extra_paths=[]):
        self.quit_when_done =False
        self.save_filename = None
        self.compress_saves = True
        self.f = None
        self.use_preview = True

        self.four_d_sensitives = []
        # window widget

        self.set_icon()
        
        self.window = gtk.Window()
        self.window.set_default_size(900,700)
        self.window.connect('delete-event', self.quit)

        # keyboard handling
        self.keymap = {
            gtk.keysyms.Left : self.on_key_left,
            gtk.keysyms.Right : self.on_key_right,
            gtk.keysyms.Up : self.on_key_up,
            gtk.keysyms.Down : self.on_key_down,
            gtk.keysyms.Escape : self.on_key_escape
            }

        self.accelgroup = gtk.AccelGroup()
        self.window.add_accel_group(self.accelgroup)
        self.window.connect('key-release-event', self.on_key_release)

        # create fractal compiler and load standard formula and
        # coloring algorithm files
        self.compiler = fc.instance

        for path in extra_paths:
            self.compiler.add_func_path(path)

        self.recent_files = preferences.userPrefs.get_list("recent_files")
        
        self.vbox = gtk.VBox()
        self.window.add(self.vbox)
        
        self.f = gtkfractal.T(self.compiler,self)            
        self.f.freeze() # create frozen - main prog will thaw us
        self.create_subfracts(self.f)
        
        self.set_filename(None)
        
        try:
            # try to make default image more interesting
            self.f.set_cmap(fractconfig.instance.find_resource(
                "basic.map",
                "maps",
                "maps"))
        except Exception, ex:
            #print ex
            pass
            
        self.model = model.Model(self.f)

        preferences.userPrefs.connect(
            'image-preferences-changed',
            self.on_prefs_changed)

        browser.update(self.f.forms[0].funcFile, self.f.forms[0].funcName)
            
        self.create_ui()
        self.create_toolbar()
        self.create_fractal(self.f)
        self.create_status_bar()

        # create these properly later to avoid 'end from FAM server connection' messages
        self.saveas_fs = None
        self.saveimage_fs = None
        self.hires_image_fs = None
        self.open_fs = None        
        
        self.window.show_all()

        self.update_subfract_visibility(False)
        self.populate_warpmenu(self.f)
        self.update_recent_file_menu()
        
        self.update_image_prefs(preferences.userPrefs)
        
        self.statuses = [ _("Done"),
                          _("Calculating"),
                          _("Deepening (%d iterations)"),
                          _("Antialiasing"),
                          _("Paused"),
                          _("Reducing Periodicity Tolerance")]

        self.f.set_saved(True)
Example #4
0
 def test_update(self):
     b = browser.BrowserDialog(None, self.f)
     b = browser.update(None)
     m = browser_model.instance
     self.assertEqual(None, m.current.fname)
     self.assertEqual(None, m.current.formula)
 def test_update(self):
     b = browser.BrowserDialog(None,self.f)
     b = browser.update(None)
     m = browser_model.instance
     self.assertEqual(None, m.current.fname)
     self.assertEqual(None, m.current.formula)