def dropMimeData(
self,
data: QtCore.QMimeData,
action: Qt.DropAction,
row: int,
column: int,
parent: QModelIndex,
) -> bool:
if action == Qt.IgnoreAction:
return True
if not data.hasFormat("application/json/table") and not data.hasFormat(
"application/json/list"):
return False
if row != -1:
begin_row = row
elif parent.isValid():
begin_row = parent.row()
else:
begin_row = len(self._data)
if data.hasFormat("application/json/list"):
data_json = data.data("application/json/list").data().decode()
else:
data_json = data.data("application/json/table").data().decode()
new_data = json.loads(data_json)
if len(new_data) == 0 or len(new_data[0]) != 4:
return False
self.insertEntries(begin_row, new_data)
return True
def setDataFromMime(self, mime: QMimeData) -> None:
super().setDataFromMime(mime)
if d := mime.data(self.DRAG_POSITION):
data: DragFrameMime = pickle.loads(d)
if data.swap and data.index != -1:
if pl := self.findParentLayout():
try:
widget = pl.itemAt(data.index).widget()
widget = cast(DragFrame, widget)
widget._setColor(self.color)
except AttributeError as err:
logger.error(err)
def dropMimeData(
self,
data: QtCore.QMimeData,
action: Qt.DropAction,
row: int,
column: int,
parent: QModelIndex,
) -> bool:
if action == Qt.IgnoreAction:
return True
if not data.hasFormat("application/json/list"):
return False
data_json = data.data("application/json/list").data().decode()
new_data = json.loads(data_json)
if len(new_data) == 0 or len(new_data[0]) != 4:
return False
for d in new_data:
self._selected[d[0]] = False
self.dataChanged.emit(
self.index(0, 0), self.index(len(self._data), len(self._data))
)
return True
def dropMimeData(self, data: QtCore.QMimeData, action: QtCore.Qt.DropAction, row: int, column: int, parent: QtCore.QModelIndex) -> bool:
q = str(data.data("vocabularies"), encoding='utf-8')
if q == self.type:
return False
self.migration_function()
return False
def dropMimeData(
self,
data: QMimeData,
action: Qt.DropAction,
row: int = -1,
col: int = -1,
parent: QModelIndex = QModelIndex(),
):
if action == Qt.IgnoreAction or not data or not data.hasFormat(
DEFAULT_MIME_FORMAT):
return True
if row < 0 or row > len(self._selected):
position = len(self._selected)
else:
position = self._plugins[row].pluginOrder
encoded = data.data(DEFAULT_MIME_FORMAT)
stream = QDataStream(encoded, QIODevice.ReadOnly)
indexes = []
while not stream.atEnd():
srcRow = stream.readInt32()
stream.readInt32() # src column
mapItems = stream.readInt32() # role data map
for i in range(mapItems):
stream.readInt32() # map role ID
stream.readQVariant() # map role value
indexes.append(self.index(srcRow, 0))
self.setPluginsOrder(indexes, position)
return False
def getCustomData(self, type):
""" Get custom data.
Args:
type: str
Returns:
QByteArray
"""
return QMimeData.data(self.getMimeFormatForType(type))
def dropMimeData(self, mime: QMimeData, action, row: int, column: int,
parent: QModelIndex):
LOG.debug('dropMimeData at row {}'.format(row))
if action == Qt.IgnoreAction:
return True
if mime.hasFormat('text/uri-list'):
if mime.hasUrls():
LOG.debug('found urls in drop!')
paths = [
qurl.path() for qurl in mime.urls() if qurl.isLocalFile()
]
self.doc.import_files(paths) # FIXME: replace with a signal
return True
elif mime.hasFormat(self._mimetype):
# unpickle the presentation information and re-insert it
# b = base64.decodebytes(mime.text())
b = mime.data(self._mimetype)
layer_set_len, insertion_info = pkl.loads(b)
LOG.debug('dropped: {0!r:s}'.format(insertion_info))
count = len(insertion_info)
if row == -1:
row = len(self.doc) # append
# FIXME: row=col=-1 implies drop-on-parent
# which may mean replace or may mean append for composite layers
# self.insertRows(row, count)
# for i, presentation in enumerate(l):
# self.setData(self.index(row+i, 0), presentation)
order = list(range(layer_set_len))
inserted_row_numbers = []
# inserted_presentations = []
# delete_these_rows = []
insertion_point = row
uuids = []
for old_row, presentation in reversed(sorted(insertion_info)):
del order[old_row]
if old_row < insertion_point:
insertion_point -= 1
inserted_row_numbers.insert(0, old_row)
uuids.append(presentation.uuid)
# delete_these_rows.append(old_row if old_row<row else old_row+count)
# inserted_presentations.append(presentation)
order = order[:insertion_point] + inserted_row_numbers + order[
insertion_point:]
LOG.debug('new order after drop {0!r:s}'.format(order))
self.select([])
self.doc.reorder_by_indices(order)
# self.doc.insert_layer_prez(row, inserted_presentations)
# LOG.debug('after insertion removing rows {0!r:s}'.format(delete_these_rows))
# for exrow in delete_these_rows:
# self.doc.remove_layer_prez(exrow)
# self.doc.didReorderLayers.emit(order) # FUTURE: not our business to be emitting on behalf of the document
assert (count == len(insertion_info))
return True
return False
def start_drag(self, info_id):
_logger.info( "started dragging" )
mimeData = QMimeData()
mimeData.data =("/" + info_id.partition("/")[2].partition("/")[0], moose.element(info_id))
mimeData.setText(info_id)
drag = QDrag(self)
drag.setMimeData(mimeData)
pixmap = QPixmap("")
drag.setPixmap(pixmap)
# drag.setHotSpot(e.pos() - self.rect().topLeft())
dropAction = drag.start(QtCore.Qt.MoveAction)
print((" => ", dropAction))
self.select_info.set_event_type(0)
self._timer.start(0)
return
def start_drag(self, info_id):
# pixmap = QPixmap()
# painter = QPainter( pixmap )
# painter.setFont( QFont("Arial") );
# painter.drawText( QPoint(100, 100), info_id );
mimeData = QMimeData()
mimeData.data = ("/" + info_id.partition("/")[2].partition("/")[0],
moose.element(info_id))
mimeData.setText(info_id)
drag = QDrag(self)
drag.setMimeData(mimeData)
pixmap = QPixmap("")
drag.setPixmap(pixmap)
# drag.setHotSpot(e.pos() - self.rect().topLeft())
dropAction = drag.start(QtCore.Qt.MoveAction)
print(" => ", dropAction)
self.select_info.set_event_type(0)
self._timer.start(0)
return
def dropMimeData(self, mimedata: QtCore.QMimeData,
action: QtCore.Qt.DropAction, row: int, column: int,
parent: QtCore.QModelIndex) -> bool:
index_list = pickle.loads(mimedata.data(self.mime_type))
target_row = parent.row()
target_column = parent.internalId()
# The affected recipes
recipes_ids = set()
# Merge vs append
merged = False
cached = {}
# This is needed because of the rows that will be removed - the indexes aren't valid after that, so
# this is to conserve (temporarily) the status quo ante
for (index_row, index_column) in index_list:
cached[(
target_column,
target_row)] = self._item_lists[target_column][target_row][0]
if index_column == target_column:
cached[(
target_column,
index_row)] = self._item_lists[target_column][index_row][0]
else:
cached[(index_column,
index_row)] = self._item_lists[index_column][index_row]
for (index_row, index_column) in index_list:
if index_column == target_column:
# Merge operation
merged = True
source_item = cached[(target_column, index_row)]
target_item = cached[(target_column, target_row)]
# Merging an item with itself is useless
if source_item == target_item:
return False
self.changed.emit()
recipes_ids = recipes_ids.union(
[recipe.id for recipe in source_item.recipes])
self.beginRemoveRows(
self.createIndex(self.root_row, 0, self.Columns.ROOT),
index_row, index_row)
the_table = None
if self.root_row in (self.RootItems.AUTHOR,
self.RootItems.CUISINE,
self.RootItems.YIELD_UNITS):
the_query = self._session.query(data.Recipe)
if self.root_row == self.RootItems.AUTHOR:
the_query.filter(
data.Recipe.author_id == source_item.id).update(
{data.Recipe.author_id: target_item.id},
synchronize_session='evaluate')
elif self.root_row == self.RootItems.CUISINE:
the_query.filter(
data.Recipe.cuisine_id == source_item.id).update(
{data.Recipe.cuisine_id: target_item.id},
synchronize_session='evaluate')
elif self.root_row == self.RootItems.YIELD_UNITS:
the_query.filter(
data.Recipe.yield_unit_id ==
source_item.id).update(
{data.Recipe.yield_unit_id: target_item.id},
synchronize_session='evaluate')
elif self.root_row == self.RootItems.CATEGORIES:
# Categories are special. TODO: Maybe construct a (rather complicated, probably) Query instead
# of this
# Need to copy the list recipes - because making changes will alter the original recipes
recipes = [recipe for recipe in source_item.recipes]
for recipe in recipes:
if target_item not in recipe.categories:
recipe.categories.append(target_item)
recipe.categories.remove(source_item)
self._session.merge(recipe)
elif self.root_row in (self.RootItems.INGREDIENTGROUPS,
self.RootItems.INGREDIENTS):
self._session.query(data.IngredientListEntry).filter(
data.IngredientListEntry.ingredient_id ==
source_item.id).update(
{
data.IngredientListEntry.ingredient_id:
target_item.id
},
synchronize_session='evaluate')
elif self.root_row == self.RootItems.INGREDIENTUNITS:
self._session.query(data.IngredientListEntry).filter(
data.IngredientListEntry.unit_id ==
source_item.id).update(
{data.IngredientListEntry.unit_id: target_item.id},
synchronize_session='evaluate')
self._session.expire_all()
self._session.delete(source_item)
else:
# Append operation. Only allowed on Cuisine or Ingredients
self.changed.emit()
# target_item = self._item_lists[target_column][target_row][0]
target_item = cached[(target_column, target_row)]
parent_index = self._parent_row[target_column]
self.beginRemoveRows(
self.createIndex(parent_index, 0, self.Columns.ITEMS),
index_row, index_row)
if self.root_row == self.RootItems.CUISINE:
recipe = cached[(index_column, index_row)]
recipe.cuisine = target_item
elif self.root_row == self.RootItems.INGREDIENTS:
ingredient_list_entry = cached[(index_column, index_row)]
ingredient_list_entry.ingredient = target_item
self._session.refresh(target_item)
self.endRemoveRows()
if merged:
self.changeSelection.emit(parent)
return True
