www.gusucode.com > mbcguitools 工具箱 matlab 源码程序 > mbcguitools/@axestext/set.m

    function varargout = set(varargin)
%AXESTEXT Set axestext object properties
%   Classic set function for the axestext object
%   properties are:
%
%      Position      :     4-element position vector
%      Userdata
%
%   All other properties are passed through to the wrapped
%   object.

%  Copyright 2000-2011 The MathWorks, Inc. and Ford Global Technologies, Inc.


% Bail if we've not been given a axestext object
objidx=0;
DOLOOP=true;
while DOLOOP
    if isa( varargin{objidx+1}, 'axestext' )
        objidx=objidx+1;
    else
        DOLOOP=false;
    end
end
at = varargin(1:objidx);
varargin = varargin(objidx+1:end);

if ~iscell(at)
    at={at};
end

for k=1:length(at)
    wrkat=at{k};

    % loop over varargin
    for n=1:2:(nargin-2)
        switch lower(varargin{n})
            case 'position'
                set(wrkat.axes,'Position',varargin{n+1})
                ud=get(wrkat.wrappedobject,'UserData');
                if ud.clipping
                    i_clip(wrkat);
                end
            case 'userdata'
                ud=get(wrkat.wrappedobject,'UserData');
                ud.userdata=varargin{n+1};
                set(wrkat.wrappedobject,'UserData',ud);

            case 'verticalalignment'
                set(wrkat.wrappedobject,'VerticalAlignment',varargin{n+1})
                pos = get(wrkat.wrappedobject,'Position');
                switch lower(varargin{n+1})
                    case 'top'
                        pos(2)=1;
                    case 'middle'
                        pos(2)=0.5;
                    case 'bottom'
                        pos(2)=0;
                end
                set(wrkat.wrappedobject,'Position',pos)
            case 'horizontalalignment'
                set(wrkat.wrappedobject,'HorizontalAlignment',varargin{n+1})
                pos = get(wrkat.wrappedobject,'Position');
                switch lower(varargin{n+1})
                    case 'right'
                        pos(1)=1;
                    case 'center'
                        pos(1)=0.5;
                    case 'left'
                        pos(1)=0;
                end
                set(wrkat.wrappedobject,'Position',pos)                
            case 'clipping'
                i_setclip(wrkat,varargin{n+1});
            case 'string'
                i_setstring(wrkat,varargin{n+1});
            case 'shortstring'
                ud=get(wrkat.wrappedobject,'UserData');
                ud.altstring=varargin{n+1};
                ud.altstringext=[];
                set(wrkat.wrappedobject,'UserData',ud);
                if ud.clipping
                    i_clip(wrkat);
                end
            case 'rotation'
                set(wrkat.wrappedobject,'Rotation',varargin{n+1});
            case 'parent'
                set(wrkat.axes,'Parent',varargin{n+1})
            case 'showback'
                ud=get(wrkat.wrappedobject,'UserData');
                ud.showback = varargin{n+1};
                set(wrkat.wrappedobject,'UserData',ud);
                if strcmp(get(wrkat,'Visible'),'on')
                    set(wrkat.background,'Visible',mbconoff(ud.showback))
                end
            case 'visible'
                set(wrkat.wrappedobject,'Visible',varargin{n+1});
                if strcmp(varargin{n+1},'on')
                    ud=get(wrkat.wrappedobject,'UserData');
                    set(wrkat.background,'Visible',mbconoff(ud.showback))
                else
                    set(wrkat.background,'Visible','off')
                end
                
            otherwise
                set(wrkat.wrappedobject,varargin{n},varargin{n+1});
        end
    end
    at{k}=wrkat;
end
% resurrect outputs
varargout=at;






function i_setclip(at,clip)
ud=get(at.wrappedobject,'UserData');

val=find( strncmpi( clip,{'off'; 'on'},length(clip) ) )-1;
if ~isempty(val) && val~=ud.clipping
    ud.clipping=val;
    if val
        % clipping on
        ud.string=get(at.wrappedobject,'String');
        ud.stringext=get(at.wrappedobject,'Extent');
        set(at.wrappedobject,'UserData',ud);
        i_clip(at);
    else
        % clipping off
        set(at.wrappedobject,'String',ud.string);
        ud.string='';
        ud.stringext=[];
        set(at.wrappedobject,'UserData',ud);
    end
end
return



function i_setstring(at,str)
ud=get(at.wrappedobject,'UserData');

if ud.clipping
    ud.string=str;
    % set the extent.
    ud.stringext=[];
    set(at.wrappedobject,'UserData',ud);
    i_clip(at);
else
    set(at.wrappedobject,'String',str);
end
return



function i_clip(at)
ud=get(at.wrappedobject,'UserData');

% clip horizontally
if isempty(ud.stringext)
    set(at.wrappedobject,'String',ud.string);
    ud.stringext=get(at.wrappedobject,'Extent');
end

% form first guess
if ud.stringext(3)>ud.position(3)
    if ~isempty(ud.altstring)
        set(at.wrappedobject,'String',ud.altstring);
        if isempty(ud.altstringext)
            ud.altstringext=get(at.wrappedobject,'Extent');
        end
        strext=ud.altstringext(3);
        workstr=ud.altstring;
    else
        strext=ud.stringext(3);
        workstr=ud.string;
    end
    if strext>ud.position(3)
        if strcmp(get(at.wrappedobject,'Interpreter'),'tex')
            % Look for non-printing tex strings - these should not
            % contribute to the character count.  These regexp's need to be
            % split apart to work correctly.

            % Tex sequence modifiers
            tokeep = true(size(workstr));
            [startseq, endseq] = regexp(workstr, ...
                '\\fontsize{.*[^\\]}|\\bf|\\rm|\\it|\\sl', ...
                'start', 'end');           
            % Single tex chars
            [singlestartseq, singleendseq] = regexp(workstr, ...
                '[^\\][_\^{}]+|^[_\^{}]', ...
                'start', 'end');
            %Deal with printing tex by treating the tex strings as a single
            %character
            [printstartseq, printendseq] = regexp(workstr, ...
                '\\lambda|\\alpha|\\beta|\\phi|\\', ...
                'start', 'end');

            for n = 1:length(startseq)
                tokeep(startseq(n):endseq(n)) = false;
            end
            for n = 1:length(singlestartseq)
                % These matches start too early so we need to add one to
                % the start
                tokeep(singlestartseq(n)+1:singleendseq(n)) = false;
            end
            for n = 1:length(printstartseq)
                % Leave first match char to be counted
                tokeep(printstartseq(n)+1:printendseq(n)) = false;
            end
            
            % Find ideal break index in the string
            nchar=floor(sum(tokeep).*ud.position(3)./strext);

            if nchar>0
                breakidx = find(tokeep, nchar, 'first');
                breakidx = breakidx(end);
                texcharbreak = (breakidx==printstartseq);
                if any(texcharbreak)
                    %Don't break on a "\", include entire tex char
                    breakidx = printendseq(texcharbreak);
                end
               
                str=ud.string(1:breakidx);

                % Check the broken string for unbalanced {} pairs
                nopenb = length(regexp(str, '^{|[^\\]{', 'start'));
                ncloseb = length(regexp(str, '[^\\]}', 'start'));
                if nopenb>ncloseb
                    str = [str, repmat('}',1,nopenb-ncloseb)];
                end
            else
                str = workstr;
            end
        else
            nchar=floor(length(workstr).*ud.position(3)./strext);
            str=workstr(1:nchar);
        end
        set(at.wrappedobject,'String',str);
    end
end
set(at.wrappedobject,'UserData',ud);