'''
Copyright (C) 2015 Taylor University, CG Cookie
Created by Dr. Jon Denning and Spring 2015 COS 424 class
Some code copied from CG Cookie Retopoflow project
https://github.com/CGCookie/retopoflow
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
'''
import bpy
import bgl
from mathutils import Vector, Matrix, Euler
import math
import time
from bpy.types import Operator
from bpy.types import SpaceView3D
from bpy_extras.view3d_utils import location_3d_to_region_2d, region_2d_to_vector_3d
from bpy_extras.view3d_utils import region_2d_to_location_3d, region_2d_to_origin_3d
from .common.debug import debugger
from .common.utils import registered_object_add, registered_check
#from .lib.common_classes import TextBox
#from . import key_maps
class ModalOperator(Operator):
def initialize(self, FSM=None):
# make sure that the appropriate functions are defined!
# note: not checking signature, though :(
dfns = {
'start_poll': 'start_poll(self,context)',
'start': 'start(self,context)',
'end': 'end(self,context)',
'end_commit': 'end_commit(self,context)',
'end_cancel': 'end_cancel(self,context)',
'update': 'update(self,context)',
'draw_postview': 'draw_postview(self,context)',
'draw_postpixel': 'draw_postpixel(self,context)',
'modal_wait': 'modal_wait(self,context,eventd)',
}
lbad = [fnname for fnname in dfns.keys() if not hasattr(self, fnname)]
if lbad:
print('Critical Error! Missing definitions for the following functions:')
for fnname in lbad: print(' %s' % dfns[fnname])
assert False, 'Modal operator missing definitions: %s' % ','.join(dfns[fnname] for fnname in lbad)
self.events_nav = {'MIDDLEMOUSE', 'SHIFT+MIDDLEMOUSE','WHEELINMOUSE','WHEELOUTMOUSE', 'WHEELUPMOUSE','WHEELDOWNMOUSE'}
self.FSM = {} if not FSM else dict(FSM)
self.FSM['main'] = self.modal_main
self.FSM['nav'] = self.modal_nav
self.FSM['wait'] = self.modal_wait
registered_object_add(self)
self.initialized = True
def get_event_details(self, context, event):
'''
Construct an event dictionary that is *slightly* more
convenient than stringing together a bunch of logical
conditions
'''
event_ctrl = 'CTRL+' if event.ctrl else ''
event_shift = 'SHIFT+' if event.shift else ''
event_alt = 'ALT+' if event.alt else ''
event_oskey = 'OSKEY+' if event.oskey else ''
event_ftype = event_ctrl + event_shift + event_alt + event_oskey + event.type
event_pressure = 1 if not hasattr(event, 'pressure') else event.pressure
return {
'context': context,
'region': context.region,
'r3d': context.space_data.region_3d,
'ctrl': event.ctrl,
'shift': event.shift,
'alt': event.alt,
'value': event.value,
'type': event.type,
'ftype': event_ftype,
'press': event_ftype if event.value=='PRESS' else None,
'release': event_ftype if event.value=='RELEASE' else None,
'mouse': (float(event.mouse_region_x), float(event.mouse_region_y)),
'pressure': event_pressure,
}
def handle_exception(self, serious=False):
errormsg, errorhash = debugger.get_exception_info_and_hash()
# if max number of exceptions occur within threshold of time, abort!
print('\n',errormsg)
curtime = time.time()
self.exceptions_caught += [(errormsg, curtime)]
# keep exceptions that have occurred within the last 5 seconds
self.exceptions_caught = [(m,t) for m,t in self.exceptions_caught if curtime-t < 5]
# if we've seen the same message before (within last 5 seconds), assume
# that something has gone badly wrong
c = sum(1 for m,t in self.exceptions_caught if m == errormsg)
if serious or c > 1:
print('\n'*5)
print('-'*100)
print('Something went wrong. Please start an error report with CG Cookie so we can fix it!')
print('-'*100)
print('\n'*5)
#show_error_message('Something went wrong. Please start an error report with CG Cookie so we can fix it!', wrap=240)
self.exception_quit = True
self.fsm_mode = 'main'
pass
####################################################################
# Draw handler function
def draw_callback_postview(self, context):
if not registered_check(): return
bgl.glPushAttrib(bgl.GL_ALL_ATTRIB_BITS) # save OpenGL attributes
try: self.draw_postview(context)
except: self.handle_exception()
bgl.glPopAttrib() # restore OpenGL attributes
def draw_callback_postpixel(self, context):
if not registered_check(): return
bgl.glPushAttrib(bgl.GL_ALL_ATTRIB_BITS) # save OpenGL attributes
try: self.draw_postpixel(context)
except: self.handle_exception()
bgl.glPopAttrib() # restore OpenGL attributes
####################################################################
# FSM modal functions
def modal_nav(self, context, eventd):
'''
Determine/handle navigation events.
FSM passes control through to underlying panel if we're in 'nav' state
'''
handle_nav = False
handle_nav |= eventd['ftype'] in self.events_nav
if handle_nav:
self.post_update = True
self.is_navigating = True
return 'main' if eventd['value']=='RELEASE' else 'nav'
self.is_navigating = False
return ''
def modal_main(self, context, eventd):
'''
Main state of FSM.
This state checks if navigation is occurring.
This state calls auxiliary wait state to see into which state we transition.
'''
# handle general navigationvrot = context.space_data.region_3d.view_rotation
nmode = self.FSM['nav'](context, eventd)
if nmode: return nmode
# accept / cancel
if eventd['press'] in {'RET', 'NUMPAD_ENTER'}:
# commit the operator
# (e.g., create the mesh from internal data structure)
return 'finish'
if eventd['press'] in {'ESC'}:
# cancel the operator
return 'cancel'
# handle general waiting
try:
nmode = self.FSM['wait'](context, eventd)
if nmode: return nmode
except:
self.handle_exception()
return ''
return ''
def modal_start(self, context):
'''
get everything ready to be run as modal tool
'''
self.fsm_mode = 'main'
self.mode_pos = (0, 0)
self.cur_pos = (0, 0)
self.is_navigating = False
self.cb_pv_handle = SpaceView3D.draw_handler_add(self.draw_callback_postview, (context, ), 'WINDOW', 'POST_VIEW')
self.cb_pp_handle = SpaceView3D.draw_handler_add(self.draw_callback_postpixel, (context, ), 'WINDOW', 'POST_PIXEL')
context.window_manager.modal_handler_add(self)
#context.area.header_text_set(self.bl_label)
self.footer = ''
self.footer_last = ''
try: self.start(context)
except: self.handle_exception()
def modal_end(self, context):
'''
finish up stuff, as our tool is leaving modal mode
'''
try: self.end(context)
except: self.handle_exception()
SpaceView3D.draw_handler_remove(self.cb_pv_handle, "WINDOW")
SpaceView3D.draw_handler_remove(self.cb_pp_handle, "WINDOW")
context.area.header_text_set()
def modal(self, context, event):
'''
Called by Blender while our tool is running modal.
This is the heart of the finite state machine.
'''
# if something bad happened, bail!
if not registered_check() or self.exception_quit:
print('Something bad happened, so we are bailing!')
self.modal_end(context)
context.area.tag_redraw()
return {'CANCELLED'}
if not context.area: return {'RUNNING_MODAL'}
context.area.tag_redraw() # force redraw
eventd = self.get_event_details(context, event)
try:
self.cur_pos = eventd['mouse']
nmode = self.FSM[self.fsm_mode](context, eventd)
self.mode_pos = eventd['mouse']
except:
self.handle_exception()
return {'RUNNING_MODAL'}
if nmode == 'wait': nmode = 'main'
self.is_navigating = (nmode == 'nav')
if nmode == 'nav':
return {'PASS_THROUGH'} # pass events (mouse,keyboard,etc.) on to region
if nmode in {'finish','cancel'}:
if nmode == 'finish':
self.end_commit(context)
else:
self.end_cancel(context)
self.modal_end(context)
return {'FINISHED'} if nmode == 'finish' else {'CANCELLED'}
if nmode: self.fsm_mode = nmode
return {'RUNNING_MODAL'} # tell Blender to continue running our tool in modal
def invoke(self, context, event):
'''
called by Blender when the user invokes (calls/runs) our tool
'''
assert getattr(self, 'initialized', False), 'Must initialize operator before invoking'
if not registered_check(): return {'CANCELLED'}
#print('clearing exceptions')
self.exceptions_caught = []
self.exception_quit = False
try:
if not self.start_poll(context): # can the tool get started?
return {'CANCELLED'}
except:
self.handle_exception()
return {'CANCELLED'}
self.modal_start(context)
return {'RUNNING_MODAL'} # tell Blender to continue running our tool in modal