There is no direct method, but there are ways to debug this.  A good practice is to minimize the amount of explicit code in an embedded component.  I usually limit this to a single procedure call.  When that procedure call is not working, I then use the maple debugger to find out why.  I have a personal set of tools for doing so, but here is a simplified version that might help.  Create the Maple procedure

dbg := proc(p) stopat(p); p; end proc:

It sets a breakpoint in the procedure passed to it, then returns the procedure.  Modify the code used for the non-working button to
 

dbg(CatchMeNot)();

Now, when you click the button you get an error, Error (in stopat) procedure name expected.  That indicates that CatchMeNot is not actually assigned a procedure, which is the case.  If it were assigned a procedure, then it would have launched the debugger and you could step through its code to find say, an operational error.

The DynamicSystems package has GainMargin and PhaseMargin commands to do precisely that.

If you want globals, a simple method is

Vector([cat(v__,1..3)]):

Note that you can use multiple ranges, or a mix of ranges and other stuff in cat
 

 cat(x, 1..3, `_`, 2..4);
                                  x1_2, x1_3, x1_4, x2_2, x2_3, x2_4, x3_2, x3_3, x3_4

Ranges do not have to be numeric
 

cat(x, "a" .. "b", `_`, 2..4);
                                           xa_2, xa_3, xa_4, xb_2, xb_3, xb_4

Have you looked at the ImageTools package?

One solution is

type(f(g(1),3,3,4),'And(specfunc(f), patfunc(specfunc(posint,g),posint))');
                             true

The annotation associated with each port defines its position.  Change the extents to

extent = {{-120, 40},{-100,60}}  // for first input
extent = {{-120, -60},{-100,-40}} // second input

Each extent has the form {{x1,y1},{x2,y2}}, the points define the diagonal of a rectangle.

Later

For a slightly nicer looking block (white background rather than see-through), add the following line, say after the model line

extends Modelica.Blocks.Icons.Block;

Another possiblity is to use ArrayTools:-Alias to allow access to a Matrix (or any rtable) created with a different offset.  For example

M := Matrix(3):  # 3x3 matrix
A := ArrayTools:-Alias(M, [0..2,0..2]):  # alias
A[0,0] := 23:
M[1,1];
                      23;

Here's how it can be solved using Syrup, which is available on the Maple Cloud:
 

with(Syrup):
ckt := [V(a+b*t+c*t^2),R,C]:
(deqs,rest) := Solve(ckt,'tran','returnall'):
dsol := dsolve(deqs):
subs(rest, dsol, v[C](t));

   -(-2*C^2*R*c+2*C*c*t+C*b+exp(-1/R/C*t)*(a/R+2*C^2*R*c-C*b))*R+c*t^2+b*t+a

Assuming this is a discrete system, here is one approach.

with(DynamicSystems):
K := [0.1, 0.2, 0.3, 0.4]:
# Assign the z-transform from the impulse response.
T := add(K[k]/z^(k-1), k=1..4);
sys := StateSpace(T,'discrete');
# Display the a, b, c, and d matrices
use sys in a,b,c,d; end use;
# Plot the impulse response
ImpulseResponsePlot(sys);

Currently there is no way to create matrix i/o using the CustomComponent template.  It wouldn't be hard to extend it to allow this.  In the meantime, you can do so by writing Modelica.  As an example, here is a block with a matrix output:

model foo
    import MBI = Modelica.Blocks.Interfaces;
    output MBI.RealOutput y[2,2] annotation (Placement(transformation(extent={{100,-10},{120,10}}))); 
equation
    y[1,1] = time;
    y[1,2] = 0;
    y[2,1] = 0;
    y[2,2] = sin(time);
end foo;

Currently the MapleSim GUI doesn't expect matrix signals; as such you won't be able to probe the output.  But you can connect it to another block that expects a Matrix input and it will work.  I've attached a simple model that does this; it uses the foo model shown above and connects it to a bar model.  MatrixIO.msim

Am not sure this is the best way to go.  It might make more sense to write a function (in the Modelica Code Editor) that returns a Matrix and then use that in a block. 

This is available via the Iterator:-Permute function.

P := Iterator:-Permute([2,1,1,3]):
for p in P do printf("%d\n", p); end do:
1 1 2 3
1 1 3 2
1 2 1 3
1 2 3 1
1 3 1 2
1 3 2 1
2 1 1 3
2 1 3 1
2 3 1 1
3 1 1 2
3 1 2 1

Using Kitonum's suggestion to answer the second question:

expand_power := proc(ex) 
local b,p; 
    (b,p) := op(ex); 
    if    p :: posint then `%*`(b $ p); 
    elif p :: negint then 1/`%*`(b$(-p)); 
    else ex; 
    end if; 
end proc:

y := x^2/z^3:
subsindets(y, `^`, expand_power);
      x %* x
     -----------
 z %* z %* z

Not quite sure what you mean by white space in this context; ReadFile returns a string with newline characters. You could do, for example,

str := FileTools:-Text:-ReadFile(somefile):
lines := StringTools:-Split(str, "\n");

to create a list of strings, one for each line in the original file.

The Syrup package, which is available on the Maple Cloud, has a ladder input notation that can be used to generate images of certain types of circuits.  For the example above you could do

ckt := [ (R1(4) &+ V1(3)) &// R2(3) &// (R3(1) &+ V2(4))]: 
Syrup:-Draw(ckt);

It's not the nicest looking rendition but is fast and easy to enter.

Differentiating the sliding average returns a delay-differential equation that dsolve can handle numerically.  That is,

deq := diff(xavg(t),t) = (x(t) - x(t-T))/T

You could then do, for the first case

dsol := dsolve(subs(T=1/2), [deq, xavg(0) = 0]), 'numeric'):
plots:=odeplot(dsol, 0..3);

The plot is shifted vertically because I set xavg(0) = 0.