Laxkit  0.0.7.1
Public Member Functions | Public Attributes | Protected Member Functions | Protected Attributes
LaxInterfaces::ViewportWindow Class Reference

Class specifically to use anInterface classes. More...

Inheritance diagram for LaxInterfaces::ViewportWindow:
Inheritance graph
[legend]

List of all members.

Public Member Functions

 ViewportWindow (anXWindow *parnt, const char *nname, const char *ntitle, unsigned long nstyle, int xx, int yy, int ww, int hh, int brder, Laxkit::Displayer *ndp=NULL)
 Constructor, pushes itself onto panner's tell stack.
virtual ~ViewportWindow ()
 Deletes dp.
virtual const charwhattype ()
virtual int init ()
virtual Laxkit::ShortcutHandlerGetShortcuts ()
virtual void Refresh ()
 Default refresh just refreshes the interfaces.
virtual void RefreshUnder ()
 Draw things before doing interface refreshes.
virtual void RefreshOver ()
 Draw things after doing interface refreshes.
virtual int LBDown (int x, int y, unsigned int state, int count, const Laxkit::LaxMouse *d)
virtual int MBDown (int x, int y, unsigned int state, int count, const Laxkit::LaxMouse *d)
 Relay MBDown to interfaces.
virtual int RBDown (int x, int y, unsigned int state, int count, const Laxkit::LaxMouse *d)
 Relay RBUp to interfaces.
virtual int LBUp (int x, int y, unsigned int state, const Laxkit::LaxMouse *d)
 Relay LBUp to interfaces.
virtual int MBUp (int x, int y, unsigned int state, const Laxkit::LaxMouse *d)
 Relay MBUp to interfaces.
virtual int RBUp (int x, int y, unsigned int state, const Laxkit::LaxMouse *d)
 Relay RBUp to interfaces.
virtual int WheelUp (int x, int y, unsigned int state, int count, const Laxkit::LaxMouse *d)
 Scroll, and zoom.
virtual int WheelDown (int x, int y, unsigned int state, int count, const Laxkit::LaxMouse *d)
 Scroll, and zoom.
virtual int MouseMove (int x, int y, unsigned int state, const Laxkit::LaxMouse *d)
virtual int KeyUp (unsigned int ch, unsigned int state, const Laxkit::LaxKeyboard *d)
virtual int CharInput (unsigned int ch, const char *buffer, int len, unsigned int state, const Laxkit::LaxKeyboard *d)
virtual int Needtodraw ()
 Return whether the viewport needs refreshing.
virtual void Needtodraw (int ntd)
virtual int Event (const Laxkit::EventData *e, const char *mes)
 Deal with messages, usually scroller events.
virtual int MoveResize (int nx, int ny, int nw, int nh)
virtual int Resize (int nw, int nh)
virtual int UseTheseScrollers (Laxkit::Scroller *x, Laxkit::Scroller *y)
 Tell the viewport to coordinate with these scrollers, replacing the current ones.
virtual int UseTheseRulers (Laxkit::RulerWindow *x, Laxkit::RulerWindow *y)
 Use these x and y rulers.
virtual int SetSpace (double minx, double maxx, double miny, double maxy)
 Set the viewport space bounds.
virtual int Push (anInterface *i, int where, int absorbcount)
 Push i onto the stack, call i->Dp(dp), then i->InterfaceOn();.
virtual int HasInterface (int iid)
 Return whether an inteface with the given id is on the interfaces stack.
virtual anInterfacePop (anInterface *i, char deletetoo=0)
 Call i->InterfaceOff(), Pop i and children of i, and either return i, or delete it.
virtual anInterfacePopId (int iid, char deletetoo=0)
 Search for the interface with the given id, then remove and return it.
virtual void postmessage (const char *mes)
 Default is app->postmessage(mes), unless parent is ViewerWindow, then try to set its message bar to mes.
virtual int NewData (SomeData *d, ObjectContext **oc_ret)
 Used when an interface wants to insert a brand new object d at the current context.
virtual int DeleteObject ()
 Delete the current object.
virtual ObjectContextObjectMoved (ObjectContext *oc, int modifyoc)
virtual int ChangeContext (int x, int y, ObjectContext **oc)
 Call this to update the context to correspond to screen coordinate (x,y).
virtual int ChangeContext (ObjectContext *oc)
 Call this to update the context to correspond to oc.
virtual int ChangeObject (ObjectContext *oc, int switchtool)
 Change the current object to be (already existing object) at oc.
virtual double * transformToContext (double *m, ObjectContext *oc, int invert, int full)
 Return the extra transform needed to transform points in oc to viewer space.
virtual int FindObject (int x, int y, const char *dtype, SomeData *exclude, int start, ObjectContext **oc)
 Iteratively find an object with whattype dtype under screen position (x,y).
virtual int FindObjects (Laxkit::DoubleBBox *box, char real, char ascurobj, SomeData ***data_ret, ObjectContext ***c_ret)
 Return a list of all the objects within box.
virtual int SelectObject (int i)
 Select previous (i==-2) or next (i==-1) object. Return 1 for current object changed, 0 for not changed.
virtual flatpoint realtoscreen (flatpoint r)
 Do a little extra checking to find what point r should correspond to.
virtual flatpoint screentoreal (int x, int y)
 Do a little extra checking to find what point (x,y) should correspond to.
virtual double Getmag (int c=0)
 Do a little extra checking to find what the magnification is.
virtual double GetVMag (int x, int y)
 Do a little extra checking to find what the magnification is.
- Public Member Functions inherited from Laxkit::PanUser
 PanUser (PanController *npan=NULL)
 Create with a new panner.
virtual ~PanUser ()
 Removes this from panner tellstack. Delete panner if necessary.
virtual PanControllercreateNewPanner (PanController *pan=NULL)
 Create a new panner that is a copy of pan if given.
virtual void UseThisPanner (PanController *npanner)
 Replace the current panner with npanner, which can be NULL to mean make a new one.
- Public Member Functions inherited from Laxkit::anXWindow
 anXWindow (anXWindow *parnt, const char *nname, const char *ntitle, unsigned long nstyle, int xx, int yy, int ww, int hh, int brder, anXWindow *prev, unsigned long nowner, const char *nsend)
 Constructor.
virtual ~anXWindow ()
 anXWindow destructor. Its X window should have been XDestroy'd before here.
virtual const charWindowTitle (int which=0)
 Return basically the name of the window.
virtual void WindowTitle (const char *newtitle)
 Change the title of the window. This text would usually be displayed in the bar provided by a window manager.
virtual const chartooltip (int mouseid=0)
 By default, return win_tooltip.
virtual const chartooltip (const char *newtooltip)
 Replace the current tooltip, return the current tooltip (after replacing).
virtual anXWindowfindChildWindowByTitle (const char *title)
 Find the first immediate child window that has win_title==title.
virtual anXWindowfindChildWindowByName (const char *name)
 Find the first immediate child window that has win_name==name.
virtual int Grayed ()
 Return whether this window is grayed.
virtual int Grayed (int g)
 Set the gray state of this window. Returns Grayed(void).
virtual int preinit ()
virtual int close ()
 Called by anXApp from anXApp::destroywindow() when a window is to be destroyed.
virtual int Idle (int tid=0)
 anXWindow::Idle() is an empty placeholeder. Just returns 1.
virtual DisplayerMakeCurrent ()
virtual int deletenow ()
 Return whether the window is allowed to be deleted.
virtual int setWinStyle (unsigned int stylebit, int newvalue)
 Control various window related basic styling of win_style.
virtual int getWinStyle (unsigned int stylebit)
 Currently, simply return win_style&stylebit.
virtual void installColors (WindowColors *newcolors)
 Dec_count old and inc_count new.
virtual int ExposeChange (ScreenEventData *e)
 Default behavior on Expose events is to call Needtodraw(1).
virtual int DeviceChange (const DeviceEventData *e)
virtual int ButtonDown (int button, int x, int y, unsigned int state, int count, const LaxMouse *m)
virtual int ButtonUp (int button, int x, int y, unsigned int state, const LaxMouse *m)
virtual int FocusOn (const FocusChangeData *e)
 Increment win_active, and highlights the window's border, if the event refers to this window.
virtual int FocusOff (const FocusChangeData *e)
 Decrements win_active, and de-highlights the window's border if win_active==0, if event is a real focus off.
virtual void contentChanged ()
 Windows may call this when their contents change.
virtual void selectionChanged ()
 Windows may call this when their selections change.
virtual anXWindowGetController ()
 Return the window most relevant for tab control loops.
virtual int SelectNextControl (const LaxDevice *d)
 Transfer focus to nextcontrol.
virtual int SelectPrevControl (const LaxDevice *d)
 Transfer the focus to prevcontrol.
virtual void ControlActivation (int on)
 Do special activation or not when controls are activated by tabbing.
virtual int AddPrevControl (anXWindow *prev)
virtual int AddNextControl (anXWindow *next)
virtual int ConnectControl (anXWindow *towhat, int after=1)
 Connect towhat to this. Used for tab loops.
virtual int CloseControlLoop ()
 Close a tab loop.
virtual void SetOwner (anXWindow *nowner, const char *mes=NULL, unsigned int send_mask=0)
 Set the new owner and control message.
virtual void SetOwner (unsigned long nowner_id, const char *mes=NULL, unsigned int send_mask=0)
virtual void dump_out (FILE *f, int indent, int what, anObject *context)
 Simple dumping function.
virtual LaxFiles::Attributedump_out_atts (LaxFiles::Attribute *att, int what, anObject *context)
virtual void dump_in_atts (LaxFiles::Attribute *att, int flag, anObject *context)
- Public Member Functions inherited from Laxkit::Tagged
virtual int HasTag (const char *tag, int casematters)
 Return whether the tag exists.
virtual int NumberOfTags ()
 Return the number of tags, strangely enough.
virtual const charGetTag (int i)
 Return const pointer to the tag text for tag number i, where i==0 is the first tag.
virtual charGetAllTags ()
 Return a new char[] with a space separated list of all the tags.
virtual int InsertTags (const char *tags, int casematters)
 Insert tags from a string such as 'tag1 tag2 tag3 "tag with spaces" tag4'.
virtual int InsertTag (const char *tag, int casematters)
 Insert tag if it doesn't exist already.
virtual int RemoveTag (const char *tag)
 The tag must be an exact match.
virtual int RemoveTag (int i)
 Remove tag number i. i must be in range [0..NumberOfTags()-1].
virtual void FlushTags ()
- Public Member Functions inherited from LaxFiles::DumpUtility
virtual void dump_in (FILE *f, int indent, int what, Laxkit::anObject *loadcontext, Attribute **att)
 Read in a file segment as an Attribute, and pass parsing duties to dump_in_atts.
virtual ~DumpUtility ()
 Empty virtual destructor.
- Public Member Functions inherited from Laxkit::aDrawable
 aDrawable (Drawable d=0)
virtual int DrawableType ()
virtual int ValidDrawable ()

Public Attributes

Laxkit::Displayerdp
 This a local dp that is used by the interfaces acting on the window.
Laxkit::RefPtrStack< anInterfaceinterfaces
 Stack of interfaces acting on the current display.
- Public Attributes inherited from Laxkit::PanUser
PanControllerpanner
- Public Attributes inherited from Laxkit::anXWindow
WindowColorswin_colors
anXAppapp
charwin_name
 An arbitrary string to be used as an id.
charwin_title
 The title of the window.
anXWindowwin_parent
int win_screen
unsigned long win_style
int win_x
int win_y
int win_w
int win_h
unsigned int win_border
int win_pointer_shape
 Identifier for a stock mouse shape.
char win_on
 Nonzero if the window is mapped.
char win_active
 Should be positive when the window has a keyboard focus, 0 otherwise.
unsigned long win_owner
 Who gets control messages from this window.
unsigned int win_owner_send_mask
charwin_sendthis
 The type of message that gets sent to owner.
anXWindownextcontrol
anXWindowprevcontrol
- Public Attributes inherited from Laxkit::Tagged
int sorttags

Protected Member Functions

virtual int PerformAction (int action)
virtual void syncrulers (int which=3)
 Sync xruler if (which&1), and yruler if (which&2).
virtual void syncWithDp ()
 This will take the space settings in dp, and coordiate the rulers and scrollers.
- Protected Member Functions inherited from Laxkit::anXWindow
virtual int deletekid (anXWindow *w)
 Purges child anXWindows from window's child stack.
virtual void SwapBuffers ()
 Swap buffers. This should be called from Refresh() if VIEWPORT_BACK_BUFFER is set in win_style.
virtual void SetupBackBuffer ()
 Initialize the backbuffer.

Protected Attributes

int interfacemenu
char firsttime
double view_shift_amount
int last_mouse
int searchx
int searchy
const charsearchtype
Laxkit::ButtonDownInfo buttondown
Laxkit::ShortcutHandlersc
Laxkit::RulerWindowxruler
Laxkit::RulerWindowyruler
Laxkit::Scrollerxscroller
Laxkit::Scrolleryscroller
- Protected Attributes inherited from Laxkit::anXWindow
charwin_tooltip
 Convenience variable to hold the window's tooltip, if any.
int needtodraw
RefPtrStack< anXWindow_kids
 Stack of children of the window.
- Protected Attributes inherited from Laxkit::Tagged
PtrStack< charlist_of_tags

Detailed Description

Class specifically to use anInterface classes.

ViewportWindow has a stack of anInterfaces. Input filters down from highest to lowest index of interfaces. Also contains a Displayer and has basic screen orientation controls including shifting, scaling, and rotation via the right button and Shift, Control, and Shift+Control respectively. Any number of interfaces can stack on this window. Key and mouse events are filtered down from the top (highest index) of the stack to the bottom. Interfaces can choose to absorb the event or not. The convention here is for 0 to be returned from an interface if it does absorb the event.

The viewport can automatically notify rulers and scrollbars of changes to the viewport configuration. However, this class does not maintain those things itself. See ViewerWindow or ScrolledWindow for a class that does that. Any scroller and ruler here is assumed to be non-local, that is, they are not created, held, or destroyed by this class.

In terms of actual object handling, this class is really an empty shell. See ViewportWithStack for a class that implements a plain stack of objects, and is able to search through the list and also draw the items in its stack.

In general, a subclassed Viewport should (re)define these functions: NewData(), DeleteObject(), ChangeObject(), ChangeContext(), ObjectMoved(), FindObject(), FindObjects(), SelectObject(), transformToContext(double *m,ObjectContext *oc,int invert,int full).

Todo:

must have some mechanism to notify anyone who wants to know where the mouse is, like mouse coordinate displays...***-> incorporate PanController that uses doubles?

the zoom handles on scrollers propagate shearing errors.. need to make a double scroller or something.

Window styles:

#define VIEWPORT_NO_XSCROLLER (1<<16)
#define VIEWPORT_NO_YSCROLLER (1<<17)
#define VIEWPORT_NO_SCROLLERS (1<<18)
#define VIEWPORT_NO_XRULER (1<<19)
#define VIEWPORT_NO_YRULER (1<<20)
#define VIEWPORT_NO_RULERS (1<<21)
#define VIEWPORT_ROTATABLE (1<<22)
#define VIEWPORT_BACK_BUFFER (1<<23)
#define VIEWPORT_RIGHT_HANDED (1<<24)

Constructor & Destructor Documentation

LaxInterfaces::ViewportWindow::ViewportWindow ( anXWindow parnt,
const char nname,
const char ntitle,
unsigned long  nstyle,
int  xx,
int  yy,
int  ww,
int  hh,
int  brder,
Laxkit::Displayer ndp = NULL 
)

Constructor, pushes itself onto panner's tell stack.

If ndp is not null, then use that Displayer rather than the default xlib based Displayer. The pointer is transfered to this viewport (not copied or duplicated), and is deleted in the destructor.

References dp, Laxkit::newDisplayer, Laxkit::Displayer::NewTransform(), Laxkit::PanController::pan_style, Laxkit::Displayer::SetSpace(), Laxkit::PanController::tell(), and Laxkit::Displayer::UseThisPanner().


Member Function Documentation

int LaxInterfaces::ViewportWindow::ChangeContext ( int  x,
int  y,
ObjectContext **  oc 
)
virtual

Call this to update the context to correspond to screen coordinate (x,y).

Default here is to set *co=NULL (if oc!=NULL).

oc will be set to point to the new context.

Derived classes would change the current context to refer to a page different from previous page, for instance. Interfaces would call this when there is a click on blank space. The ViewportWindow then updates accordingly, and then the interface can set up new data according to this new context.

Return 0 for context changed, nonzero for not.

Reimplemented in LaxInterfaces::ViewportWithStack.

Referenced by LaxInterfaces::CaptionInterface::LBDown(), LaxInterfaces::ImageInterface::LBDown(), LaxInterfaces::RectInterface::LBDown(), and LaxInterfaces::PathInterface::LBDown().

int LaxInterfaces::ViewportWindow::ChangeContext ( ObjectContext oc)
virtual

Call this to update the context to correspond to oc.

This is a reduced form of NewData(), for when you simply want to change context, rather than introduce new data. The contents of oc must not be modified.

The default here is just an empty placeholder. Return 0 for context changed.

int LaxInterfaces::ViewportWindow::ChangeObject ( ObjectContext oc,
int  switchtool 
)
virtual

Change the current object to be (already existing object) at oc.

Returns 1 for current object changed, otherwise 0 for not changed or bad context.

This function is an empty placeholder, and just returns 0.

Todo:
*** need mechanism to pass the LBDown grab to the object's interface.. This function is most often called when interfaces cannot find objects of their own to work on on an LBDown.

Reimplemented in LaxInterfaces::ViewportWithStack.

Referenced by LaxInterfaces::CaptionInterface::LBDown(), LaxInterfaces::ImageInterface::LBDown(), LBDown(), LaxInterfaces::GradientInterface::LBDown(), LaxInterfaces::RectInterface::LBDown(), and LaxInterfaces::PathInterface::LBDown().

int LaxInterfaces::ViewportWindow::CharInput ( unsigned int  ch,
const char buffer,
int  len,
unsigned int  state,
const Laxkit::LaxKeyboard d 
)
virtual
int LaxInterfaces::ViewportWindow::DeleteObject ( )
virtual

Delete the current object.

This is a placeholder, and only calls anInterface::Clear() on all current interfaces. Derived classes should redefine to do something useful, which might not be calling Clear() on the interfaces!

Return 1 if object deleted, 0 if not deleted, -1 if there was no current object.

Reimplemented in LaxInterfaces::ViewportWithStack.

References Laxkit::PtrStack< T >::e, interfaces, and Laxkit::PtrStack< T >::n.

Referenced by LaxInterfaces::CaptionInterface::LBUp(), and LaxInterfaces::ImageInterface::LBUp().

int LaxInterfaces::ViewportWindow::Event ( const Laxkit::EventData e,
const char mes 
)
virtual

Deal with messages, usually scroller events.

Relay "pan change" events to the displayer, and potentially respond to ruler events. Scroller and PanPopup changes are sent via the panner. The panner sends the "pan change" in response to those changes.

Subclass should also respond to "xruler" and "yruler" events if they want to.

Reimplemented from Laxkit::anXWindow.

Reimplemented in LaxInterfaces::ViewportWithStack.

References dp, Laxkit::PtrStack< T >::e, interfaces, Laxkit::PtrStack< T >::n, Laxkit::RulerWindow::SetCurrentUnits(), Laxkit::Displayer::syncFromPanner(), and syncrulers().

int LaxInterfaces::ViewportWindow::FindObject ( int  x,
int  y,
const char dtype,
SomeData exclude,
int  start,
ObjectContext **  oc 
)
virtual

Iteratively find an object with whattype dtype under screen position (x,y).

This default function does nothing but set oc to NULL and returns 0. It should be redefined in subclasses.

Interfaces expect this function to behave as follows:

Todo:
*** this needs a little more clarification...

This function is used to progressively find objects that may be hidden but are still under screen point (x,y). If start==0 and *oc points to something, then the search starts with the object immediately after oc.

If dtype==NULL, then search for any object under (x,y), otherwise restrict search to dtype objects, where dtype is data->whattype().

Returns 1 if a suitable object is found and oc is set to it. If the search is over and there were no suitable objects found, 0 is returned, and oc set to NULL. If the search is over but there was a matching object found of a different type, then -1 is returned and oc is set to refer to that object. The oc returned in this way must be owned by the ViewportWindow, and must not be deleted by whatever calls here.

If an object matching the given (x,y) was found, but was of the wrong type, then that object will be available returned in oc, and -1 is returned.

If an interfaces receives a lbdown outside of their object, then it would call viewport->FindObject, which will possibly return an object that the interface can handle. If so, the interface would call ChangeObject(data,0) with it. The interface can keep searching until it finds one it can handle. If FindObject does not return something the interface can handle, then the interface should call ChangeObject(that other data, 1), which should result in another interface being set to work on that data.

ViewportWindow keeps the following convenience variables about the search hanging around. Derived classes with their own search can use them however they want:

 startx,starty: the x and y position of the search
 searchtype:    the whattype string for a restricted search
 

If start!=0, OR x!=searchx OR y!=searchy then initialize the search so that exclude becomes firstobj. If start==1, then skip this new firstobj. If start==2 or start==0 (but either x or y are different), then include exclude in the search.

If this is not the start of a search, exclude will always be skipped.

Subclasses should ensure that searching does not go on infinitely, by checking against a first object. If a search steps through all objects without success, then NULL should be returned from then on.

No actual viewport state should be changed, other than the search aids. This function only returns what is asked for. An interface may then take what is returned and tell the Viewport to make that the current object, if it likes.

Reimplemented in LaxInterfaces::ViewportWithStack.

Referenced by LaxInterfaces::CaptionInterface::LBDown(), LaxInterfaces::ImageInterface::LBDown(), LBDown(), LaxInterfaces::GradientInterface::LBDown(), LaxInterfaces::RectInterface::LBDown(), and LaxInterfaces::PathInterface::LBDown().

int LaxInterfaces::ViewportWindow::FindObjects ( Laxkit::DoubleBBox box,
char  real,
char  ascurobj,
SomeData ***  data_ret,
ObjectContext ***  c_ret 
)
virtual

Return a list of all the objects within box.

If real, then box contains real bounds, rather than screen bounds. If ascurobj, then grab only those objects in box, and at the same base level as curobj.

Returns the number of objects found. If none are found, data_ret and c_ret are set to NULL. Otherwise they (if the pointer is provided) are set to a null terminated list of the objects (so it is an array of 1 more than the number the function returns), and the corresponding object contexts. The contexts are local objects to the list, so the calling code is responsible for deleting them. The data are not local, nor are their counts incremented, so the calling code should do something with them quick before they are deleted.

This function is very specific to the actual viewport, so the default here is to return no objects. Subclasses don't really have to redefine this function unless they really want provide this sort of ability. The only interface that tries to access this is ObjectInterface.

Todo:
need flag for IN box or just TOUCHING box
double LaxInterfaces::ViewportWindow::Getmag ( int  c = 0)
virtual

Do a little extra checking to find what the magnification is.

If a viewport defines pages or groups, for instance, then this allows derived interfaces to use coords on those pages and groups, rather than the plain view transform in dp->

Default is just return dp->Getmag(c).

References dp, and Laxkit::Displayer::Getmag().

double LaxInterfaces::ViewportWindow::GetVMag ( int  x,
int  y 
)
virtual

Do a little extra checking to find what the magnification is.

If a viewport defines pages or groups, for instance, then this allows derived interfaces to use coords on those pages and groups, rather than the plain view transform in dp->

Default is just return dp->GetVMag(x,y).

References dp, and Laxkit::Displayer::GetVMag().

int LaxInterfaces::ViewportWindow::HasInterface ( int  iid)
virtual

Return whether an inteface with the given id is on the interfaces stack.

Return value is index+1 if found, or 0 if not.

References Laxkit::PtrStack< T >::e, interfaces, and Laxkit::PtrStack< T >::n.

Referenced by LaxInterfaces::ViewerWindow::SelectTool().

int LaxInterfaces::ViewportWindow::init ( )
virtual

Calls:

dp->WrapWindow(this);
dp->Newmag(1);
XSetWindowBackground(app->dpy,window,win_xatts.background_pixel);
dp->NewFG(255,255,255);
dp->NewBG(0,0,0);
if (win_style&VIEWPORT_BACK_BUFFER) SetupBackBuffer();

Reimplemented from Laxkit::anXWindow.

References Laxkit::Displayer::CenterReal(), dp, Laxkit::Displayer::NewBG(), Laxkit::Displayer::NewFG(), Laxkit::Displayer::Newmag(), Laxkit::Displayer::syncPanner(), syncWithDp(), and Laxkit::Displayer::WrapWindow().

int LaxInterfaces::ViewportWindow::LBDown ( int  x,
int  y,
unsigned int  state,
int  count,
const Laxkit::LaxMouse d 
)
virtual

Relay LBDown to the interfaces. If not interfaces take it, then try to select an object at screen coordinate (x,y).

Todo:
*** need mechanism to pass the LBDown grab to the object's interface.. This function is most often called when interfaces cannot find objects of their own to work on on an LBDown. most likely, this would require a flag for ChangeObject, which would get called from the interface...?

Reimplemented from Laxkit::anXWindow.

References ChangeObject(), Laxkit::ButtonDownInfo::down(), Laxkit::PtrStack< T >::e, FindObject(), interfaces, and Laxkit::PtrStack< T >::n.

int LaxInterfaces::ViewportWindow::MBDown ( int  x,
int  y,
unsigned int  state,
int  count,
const Laxkit::LaxMouse d 
)
virtual

Relay MBDown to interfaces.

Todo:
*** have special behavior for middle button, which affects how the mouse wheel behaves. mb double click toggle between scroll up/down, scroll right/left, rotate, or zoom in/out

Reimplemented from Laxkit::anXWindow.

References Laxkit::ButtonDownInfo::down(), Laxkit::PtrStack< T >::e, interfaces, and Laxkit::PtrStack< T >::n.

int LaxInterfaces::ViewportWindow::MouseMove ( int  x,
int  y,
unsigned int  state,
const Laxkit::LaxMouse d 
)
virtual

MouseMove events are relayed to all interfaces.

***Currently, middle button drags are mapped to right button, plain middle is right-shift

If the viewport caught an RBDown, then it will shift, scale, or rotate the viewport when the mouse is moved.

Reimplemented from Laxkit::anXWindow.

References dp, Laxkit::PtrStack< T >::e, Laxkit::ButtonDownInfo::getinitial(), interfaces, Laxkit::ButtonDownInfo::isdown(), Laxkit::ButtonDownInfo::move(), Laxkit::PtrStack< T >::n, Laxkit::Displayer::Rotate(), Laxkit::RulerWindow::SetPosFromScreen(), Laxkit::Displayer::ShiftScreen(), syncWithDp(), and Laxkit::Displayer::Zoom().

int LaxInterfaces::ViewportWindow::MoveResize ( int  nx,
int  ny,
int  nw,
int  nh 
)
virtual

Does this:

anXWindow::MoveResize(nx,ny,nw,nh);
flatpoint center=dp->screentoreal(win_w/2,win_h/2);
dp->WrapWindow(this);
if (firsttime) {
if (firsttime==1) dp->CenterReal();
firsttime=0;
} else { dp->CenterPoint(center); }

Then calls ViewportResized() on each interface.

Reimplemented from Laxkit::anXWindow.

References Laxkit::Displayer::CenterPoint(), Laxkit::Displayer::CenterReal(), dp, Laxkit::PtrStack< T >::e, interfaces, Laxkit::PtrStack< T >::n, Laxkit::Displayer::screentoreal(), Laxkit::Displayer::syncPanner(), syncWithDp(), and Laxkit::Displayer::WrapWindow().

int LaxInterfaces::ViewportWindow::Needtodraw ( )
virtual

Return whether the viewport needs refreshing.

Currently, if any of the interfaces have needtodraw, then return 1.

Reimplemented from Laxkit::anXWindow.

References Laxkit::PtrStack< T >::e, interfaces, and Laxkit::PtrStack< T >::n.

int LaxInterfaces::ViewportWindow::NewData ( SomeData d,
ObjectContext **  oc_ret 
)
virtual

Used when an interface wants to insert a brand new object d at the current context.

The index of where d is placed in the current context is returned, or if there is an error, -1 is returned and no object inserted. If you have an object that was found from a viewport search, then you do not want to use this function. This function is for brand new data only. Re-inserting already existing objects will most likely make things shift around in unexpected ways. Note that this will most likely not crash the program, since the objects are reference counted.

Subclasses must redefine this to be something useful.

Subclasses might use this function to install the proper delete function to the data's SomeData::deleteMe. Derived classes can redefine this function to push the data onto the appropriate page (or whereever).

If oc_ret!=NULL, then an ObjectContext is returned there. This should be copied with oc->duplicate(), as usually it is stored internally by the viewport.

This default function does nothing, and returns -1.

Reimplemented in LaxInterfaces::ViewportWithStack.

Referenced by LaxInterfaces::GradientInterface::newData(), LaxInterfaces::CaptionInterface::newData(), LaxInterfaces::ImageInterface::newData(), and LaxInterfaces::PathInterface::newPathsData().

ObjectContext * LaxInterfaces::ViewportWindow::ObjectMoved ( ObjectContext oc,
int  modifyoc 
)
virtual

Called when moving objects around, this ensures that a move can make the object go to a different page, for instance. Typically, interfaces will call this after dragging, when the button is released.

Returns NULL if no modifications. If the context does change, then return an object with the new context. In this case, if modifyoc, then oc is changed to the new context, and oc is returned. If modifyoc==0, then return a brand new ObjectContext object.

If oc==NULL and modifyoc==1, then NULL is returned.

Default here does nothing but return NULL. Subclasses should redefine to do something meaningful.

Referenced by LaxInterfaces::CaptionInterface::LBUp(), LaxInterfaces::ImageInterface::LBUp(), and LaxInterfaces::GradientInterface::LBUp().

anInterface * LaxInterfaces::ViewportWindow::Pop ( anInterface i,
char  deletetoo = 0 
)
virtual

Call i->InterfaceOff(), Pop i and children of i, and either return i, or delete it.

If the item was pushed with a local=0, then the item is not deleted. If deletetoo==0, then return the popped interface.

This pops off not only the interface, but also any descendents of it that happen to be on the interfaces stack (i->child, i->child->child, etc.). It first calls i->InterfaceOff() then tries to remove any remaining children (calls interfaces.remove(thechildinterface)

References LaxInterfaces::anInterface::child, Laxkit::PtrStack< T >::findindex(), LaxInterfaces::anInterface::InterfaceOff(), interfaces, LaxInterfaces::anInterface::owner, Laxkit::PtrStack< T >::popp(), and Laxkit::RefPtrStack< T >::remove().

Referenced by PopId(), LaxInterfaces::ViewerWindow::PopInterface(), and LaxInterfaces::ViewerWindow::SelectTool().

void LaxInterfaces::ViewportWindow::postmessage ( const char mes)
virtual

Default is app->postmessage(mes), unless parent is ViewerWindow, then try to set its message bar to mes.

Todo:
*** implement a printf-ish postmessage("format string %d",i,....)

References LaxInterfaces::ViewerWindow::PostMessage(), and Laxkit::anXApp::postmessage().

Referenced by LaxInterfaces::PathInterface::ChangeCurpathop(), LaxInterfaces::anInterface::PostMessage(), and LaxInterfaces::PathInterface::SetPointType().

int LaxInterfaces::ViewportWindow::Push ( anInterface i,
int  where,
int  absorbcount 
)
virtual

Push i onto the stack, call i->Dp(dp), then i->InterfaceOn();.

Try to insert at position where.

Todo:
If the interface is already on the stack, then it and any descendents are brought to the top. *** that is not implemented yet, not sure if it should be.. just pushnodup's for now.

References Laxkit::anObject::dec_count(), dp, LaxInterfaces::anInterface::Dp(), LaxInterfaces::anInterface::InterfaceOn(), and interfaces.

Referenced by LaxInterfaces::PathInterface::ChangeCurpathop(), LaxInterfaces::ViewerWindow::PushInterface(), and LaxInterfaces::ViewerWindow::SelectTool().

int LaxInterfaces::ViewportWindow::RBDown ( int  x,
int  y,
unsigned int  state,
int  count,
const Laxkit::LaxMouse d 
)
virtual

Relay RBUp to interfaces.

If no interfaces claim it, then plain click pops up the context menu (***not imp), shift-drag moves viewport, control-drag scales viewport, control-shift-drag rotates the screen.

Reimplemented from Laxkit::anXWindow.

References Laxkit::ButtonDownInfo::clear(), Laxkit::ButtonDownInfo::down(), Laxkit::PtrStack< T >::e, interfaces, Laxkit::PtrStack< T >::n, and Laxkit::anXApp::rundialog().

flatpoint LaxInterfaces::ViewportWindow::realtoscreen ( flatpoint  r)
virtual

Do a little extra checking to find what point r should correspond to.

If a viewport defines pages or groups, for instance, then this allows derived interfaces to use coords on those pages and groups, rather than the plain view transform in dp->

Default is just return dp->realtoscreen(r).

References dp, and Laxkit::Displayer::realtoscreen().

void LaxInterfaces::ViewportWindow::Refresh ( )
virtual

Default refresh just refreshes the interfaces.

Here is a very basic template for a Refresh function:

//ensure drawing if an interface needs to draw
for (int c=0; c<interfaces.n; c++) interfaces.e[c]->needtodraw=1;
if (needtodraw) {
dp->StartDrawing(this);
--- draw all the stuff ---
if (backbuffer) SwapBuffers();
}
needtodraw=0;

Reimplemented from Laxkit::anXWindow.

Reimplemented in LaxInterfaces::ViewportWithStack.

References Laxkit::Displayer::ClearWindow(), dp, Laxkit::PtrStack< T >::e, Laxkit::Displayer::EndDrawing(), interfaces, Laxkit::PtrStack< T >::n, Laxkit::Displayer::NewBG(), Laxkit::Displayer::PopAxes(), Laxkit::Displayer::PushAndNewTransform(), RefreshOver(), RefreshUnder(), Laxkit::Displayer::StartDrawing(), Laxkit::anXWindow::SwapBuffers(), transformToContext(), and Laxkit::Displayer::Updates().

void LaxInterfaces::ViewportWindow::RefreshOver ( )
virtual

Draw things after doing interface refreshes.

This is called from the default ViewportWindow::Refresh() to simplify subclassing refreshing.

Referenced by Refresh().

void LaxInterfaces::ViewportWindow::RefreshUnder ( )
virtual

Draw things before doing interface refreshes.

This is called from the default ViewportWindow::Refresh() to simplify subclassing refreshing.

Referenced by Refresh().

int LaxInterfaces::ViewportWindow::Resize ( int  nw,
int  nh 
)
virtual

Does this:

flatpoint center=dp->screentoreal(win_w/2,win_h/2);
dp->WrapWindow(this);
if (firsttime) {
if (firsttime==1) dp->CenterReal();
firsttime=0;
} else { dp->CenterPoint(center); }

Then calls ViewportResized() on each interface.

Reimplemented from Laxkit::anXWindow.

References Laxkit::Displayer::CenterPoint(), Laxkit::Displayer::CenterReal(), dp, Laxkit::PtrStack< T >::e, interfaces, Laxkit::PtrStack< T >::n, Laxkit::Displayer::screentoreal(), Laxkit::Displayer::syncPanner(), syncWithDp(), and Laxkit::Displayer::WrapWindow().

flatpoint LaxInterfaces::ViewportWindow::screentoreal ( int  x,
int  y 
)
virtual

Do a little extra checking to find what point (x,y) should correspond to.

If a viewport defines pages or groups, for instance, then this allows derived interfaces to use coords on those pages and groups, rather than the plain view transform in dp->

Default is just return dp->screentoreal(r).

References dp, and Laxkit::Displayer::screentoreal().

int LaxInterfaces::ViewportWindow::SelectObject ( int  i)
virtual

Select previous (i==-2) or next (i==-1) object. Return 1 for current object changed, 0 for not changed.

This function is a dummy placeholder. It does nothing here. It is not used by the interfaces, and within the Laxkit is only called from CharInput in this class in order to select previous and next object.

Return 0 for no change, nonzero for change.

Reimplemented in LaxInterfaces::ViewportWithStack.

int LaxInterfaces::ViewportWindow::SetSpace ( double  minx,
double  maxx,
double  miny,
double  maxy 
)
virtual

Set the viewport space bounds.

If the space is allowed to be rotated, then the space bounds may not translate directly to screen bounds. The screen bounds of the space will be larger to accomodate the rotated rectangle.

Todo:
*** return value? success? on change?

References dp, Laxkit::Displayer::SetSpace(), and syncWithDp().

void LaxInterfaces::ViewportWindow::syncWithDp ( )
protectedvirtual

This will take the space settings in dp, and coordiate the rulers and scrollers.

Displayer keeps track of the workspace and the window screen. The tricky part is when the workspace is rotated, and when the axes are of different lengths, or not orthogonal.

This currently only calls syncrulers(3). Assumes that the panner and scrollers can take care of themselves.

References syncrulers().

Referenced by init(), MouseMove(), MoveResize(), Resize(), SetSpace(), UseTheseRulers(), UseTheseScrollers(), WheelDown(), and WheelUp().

double * LaxInterfaces::ViewportWindow::transformToContext ( double *  m,
ObjectContext oc,
int  invert,
int  full 
)
virtual

Return the extra transform needed to transform points in oc to viewer space.

dp->Getctm() holds a transform mapping viewer space to screen space. The transform mapping context space to screen space would be m*dp->Getctm().

If m is NULL, then return a new double[6]. Otherwise, m is assumed to be a double[6], and the transform is put there.

The default here is just to return identity.

If (invert) then m will map points from viewer space to context space.

If (!full), then return the transform up to but not including the object in oc. For instance, frequently, one deals with a context describing a particular object, but the transform one wants is to the space containing that object, not the object space itself, so one would pass full==0 in that case. This exists so that one may use SomeData::pointin() easily, because that function takes points in object parent space, not object space.

References Laxkit::transform_identity().

Referenced by Refresh().

int LaxInterfaces::ViewportWindow::UseTheseRulers ( Laxkit::RulerWindow x,
Laxkit::RulerWindow y 
)
virtual

Use these x and y rulers.

ViewportWindow configures the rulers to auto track the mouse wherever the window is in relation to the viewport.

References dp, Laxkit::Displayer::righthanded(), Laxkit::anXWindow::SetOwner(), syncWithDp(), and Laxkit::RulerWindow::TrackThisWindow().

Referenced by LaxInterfaces::ViewerWindow::init().

int LaxInterfaces::ViewportWindow::WheelDown ( int  x,
int  y,
unsigned int  state,
int  count,
const Laxkit::LaxMouse d 
)
virtual

Scroll, and zoom.

Plain wheel scrolls vertically, faster with shift. Control-wheel scrolls horizontally, faster with shift. Alt-wheel zooms.

Reimplemented from Laxkit::anXWindow.

References dp, Laxkit::PtrStack< T >::e, interfaces, Laxkit::PtrStack< T >::n, Laxkit::Displayer::ShiftScreen(), syncrulers(), syncWithDp(), and Laxkit::Displayer::Zoom().

int LaxInterfaces::ViewportWindow::WheelUp ( int  x,
int  y,
unsigned int  state,
int  count,
const Laxkit::LaxMouse d 
)
virtual

Scroll, and zoom.

Plain wheel scrolls vertically, faster with shift. Control-wheel scrolls horizontally, faster with shift. Alt-wheel zooms.

Reimplemented from Laxkit::anXWindow.

References dp, Laxkit::PtrStack< T >::e, interfaces, Laxkit::PtrStack< T >::n, Laxkit::Displayer::ShiftScreen(), syncrulers(), syncWithDp(), and Laxkit::Displayer::Zoom().


Member Data Documentation

Laxkit::Displayer * LaxInterfaces::ViewportWindow::dp

This a local dp that is used by the interfaces acting on the window.

It is a pointer rather than a reference so that viewports are not restricted to the default xlib based Displayer.

Interfaces would hold a reference to this dp, but by default it is the repsponsibility of the ViewportWindow to create and delete the dp-> This of course assumes that the ViewportWindow and its dp outlast all the interfaces.

Referenced by LaxInterfaces::ViewerWindow::AddTool(), Event(), LaxInterfaces::ViewportWithStack::FindObject(), Getmag(), GetVMag(), init(), MouseMove(), MoveResize(), Push(), realtoscreen(), LaxInterfaces::ViewportWithStack::Refresh(), Refresh(), Resize(), screentoreal(), SetSpace(), syncrulers(), UseTheseRulers(), UseTheseScrollers(), ViewportWindow(), WheelDown(), WheelUp(), and ~ViewportWindow().

Laxkit::RefPtrStack< anInterface > LaxInterfaces::ViewportWindow::interfaces

Stack of interfaces acting on the current display.

It is important for viewport to have its own instances of the interfaces. The usual method implemented by this class together with ViewerWindow is for ViewerWindow to keep a stack of possible interfaces (tools), and push and pop them to this->interfaces.

Referenced by LaxInterfaces::PathInterface::ChangeCurpathop(), CharInput(), LaxInterfaces::ViewportWithStack::DeleteObject(), DeleteObject(), LaxInterfaces::ViewportWithStack::Event(), Event(), HasInterface(), LBDown(), LBUp(), MBDown(), MBUp(), MouseMove(), MoveResize(), Needtodraw(), Pop(), PopId(), Push(), RBDown(), RBUp(), LaxInterfaces::ViewportWithStack::Refresh(), Refresh(), Resize(), WheelDown(), and WheelUp().


The documentation for this class was generated from the following files:

Mon Feb 17 2014 11:52:58, Laxkit