I found something very related to the answer here:
The procedure revolves around these steps:
1) In the opening function of the main GUI, create a handle to the main GUI for your own convenience:
handles.mainGUIhand = hObject;
2) When calling the child GUI, pass a `dummy' argument and then the handle to the parent GUI. This can be done thus:
h = ChildGUI('DummyArg', handles.mainGUIhand);
3) Now hop over to the child GUI side and grab the input arguments through the opening function. First, look for the dummy argument:
mainGuiInput = find(strcmp(varargin, 'DummyArg'));
4) Then, knowing that the handle to the main GUI follows as the next input argument after `DummyArg', grab a hold of the main GUI's handle:
handles.mainHandCell = varargin{mainGuiInput+1};
Note that varargin is a cell array.
5) Next, grab the handles to the various objects and data within your main GUI:
handles.mainHands = guidata(handles.mainHandCell);
6) Now grab the object whose callback function you want to execute, in this case a push-button called `Example':
push_Example_callback = get(handles.mainHands.push_Example, 'Callback');
7) Finally, call the function to which you just obtained the handle in the previous step. This being a push-button you need to pass it first the handle to the object that is suppose to be calling it (the parent GUI) and then the data of the said object. You can call this function from anywhere you desire (within reason), e.g. in reaction to a push-button or even in the opening function of the child GUI:
push_Example_callback(handles.mainHandCell, handles.mainHands);
A few notes:
a) The various obtained handles in the child GUI were stored in a handles-type variable in my example code so that they can be used by ay function in the child GUI. If you only need to do this from within a certain function within the child GUI, the handles can be stored in non handles-type variables.
b) I suppose that if the function you are after in the main GUI doesn't have a handle that you can grab on to, you can always wrap it inside some form of callback, perhaps to some invisible object? I don't know about that, but would be happy to know if anyone does know.
c) Can this code be made more efficient if we just pass the handle to the bits of data that we need for the program to run successfully rather than passing a handle to the entire workspace of the main GUI in step 5? Will it make much of a difference if we do, or is this handle-passing relatively computationally lightweight?