Laxkit:

General To Dos

gotta make a compiler aid:
 lax-config --cppflags --ldflags --libs --ldstaticflags --version --help --use* --cpp
			--make-laxrc <-- dump a generic laxrc to stdout with lots of comments to say how to modify it.

Ultimately need to have pictures of the various widgets in the docs..

TODO RIGHT NOW:
deb packaging: must figure out how to make 3 packages at the same time: laxkit, laxkit-dev, and laxkit-doc
application icon support! right now, any iconized programs do not have an icon..
ini file to attribute converter
tablet/XInput extension support
change to uft8
fluid-esque code generation tool
make nodebug (currently always has -g option)
start thinking about portability, particularly to osx, make a non-gnu file
 to provide gnu things like getline() and get_current_dir_name() that are not provided on,
 for instance, bsd-ish osx..
class to handle ~/.recently-used (see the spec by freedesktop.org)

TO ENHANCE:
Could have xmp,pnm,png,tiff,jpg be native to Laxkit, and work it so Imlib is no longer a requirement.
Could put all the pure math stuff in LaxMath namespace.
 this includes transformmath, vectors, and interfaces/bezier math
Could put strmanip.cc/.h in LaxStr namespace.

FEATURE WISHING:
 theme hooks?
 use fontconfig/Xft/freetype/Xrender, how about pango? antigrain?
 joystick support
 gl support
 auto double buffering?
 thread safety
 drag n drop

--Thoughts on themes--
If more than just simple colors were to be changed, what would be required? seems
like each refresh of every function would have to be externally redefinable, which
would suck.. maybe just stick to simple color changes..
Otherwise would have to have Laxkit namespace classes use a similar objectfactory
setup as LaxInterfaces, and the theme modifies the factory to return subclasses
of all the core classes. Bleah!

---GRAPHICS---
this could be part of a more comprehensive system that allows hotswapping the
whole graphics backend. The required bits are:
 font search and selection
 text out
 text out at angle
 text out by affine transform 
 line segments
 polylines, optionally filled
 circles/ellipses at any angle
 image control:
  definitely loading, perhaps saving
  copy image
  blit image at any angle, by an arbitrary affine matrix
  get a generic buffer from an image, and set an image from a generic buffer
 Get/Set line width, color, dash
 Get/Set drawing function: solid, or xor..

 don't think core lax uses more than that.
   dodads, like bevels, drawing triangle things like eject button etc. 
   could depend on the above..

This covers all the basic Laxkit controls. more specific drawing abilities are
wrapped in Displayer objects. Currently, the only implemented Displayer is based on
pure Xlib functions. there could be a CairoDisplayer, AntigrainDisplayer,
Imlib2Displayer, ImagemagickDisplayer, etc.

---SHORTCUTS---
see also shortcut.cc (which is a work in progress)
from shortcut.cc:
 A window would define a list of actions, and store a list of shortcuts pointing to those actions.
 In the window's CharInput(ch,state) function, the action number is found from it's (redefinable) shortcuts
 and something like thewindow->action(shortcut->action) is called.

 The default shortcuts can be overridden in rc files such as the main ~/.lax/laxrc. They
 can be loaded and saved via the LaxFiles::Attribute sort of format.

 ***need mechanism for chaining key shortcuts:
 For instance, defining a shortcut that is shift-control-'a' followed by "chain", it is
 listed like this: --- though chaining makes the input that much more complicated requires window
 remembering what's been pressed. or could lump yet ANOther chore on anXApp, which is to build up 
 the key shortcut based on the shortcut list stored by the window. that would mean restructuring
 anXWindow, since it is there that Xlib key codes are translated into keys.. that has to change
 anyway in conversion to utf8......

also consider being able to map mouse events. each of the below would also potentially
be modified by modifier key state: shift, control, alt, meta, etc.
this is kind of key shortcuts vs. location shortcuts
 button down
 move with no button down
 move with button down
 button up, with no drag while it was down
 button up, with drag while it was down

each of these instances would map to an action, but these would be special actions that
have a position too.

---WIDGET TODO---
number sliders, like Num: 255 [----------*---]
SliderInputPopup?== list to select from, or type in choice
table frames
multirow/col frames
fuller print dialog
font dialog
detail selector/record selector
tree selector
color selection dialog
sliding frame: v or h, drag the bar to resize.. a much simplified SplitWindow, 
     as is found in many other toolkits

CLEAN UP:
FileDialog and FilePreviewer
debug xfontsel part in textxeditbase (or just continue on with font reworking)
no zoom, viewerwindow but with integers (ScrolledWindow)
SplitWindow
Focus handling, especially for popups REALLY SUCKS right now
MenuSelector and friends
BoxArrange/RowFrame and friends
put in whattypes for all classes
perhaps redo the whole events setup. relying on X atoms leaves quite a lot of
  residue in the X server..
when a child window is destroyed, sometimes the parent doesn't know it.
  perhaps there could be a built in procedure to keep track of that..
  related:****** popup up dialogs and other controls that have owners, if the owner is destroyed,
	then the window is no longer valid!

Interfaces Todo

transformers, so patch and paths can select many nodes, apply a transformer object
 shift the nodes, or attach transformer(s) to an image, ...

implement all the DumpUtility funtions for ALL data classes and interfaces!!! Particularly when what==-1,
then the dump_out() should dump out a psuedocode human readable mock up of what file
output for that class looks like. It should be documented enough so that someone
reading it can get a good idea of how to write code for that segment of the file.

put in a what in the dump_in_*, particularly for such like: PathsData::dump_in(FILE*, LAX_SVG)

It might be useful to separate the BlahData from BlahInterface in the *.cc and *.h
files. This enables processing all the data without the need of the windowing system.
The exception here is PathsData, which requires the static PathInterface::basepathops...

some interfaces still don't have duplicate()

port ImagePatchInterface into the gimp to be used like the other
 rotate/perspective/etc transforms, because it is a feature that I CONSTANTLY ache for
 in the gimp!!!

perhaps have an Interface<template> : public InterfaceWithDp to knock out the basics easily..

anXApp todos

  TODO:

 *** VITAL!! improve focus handling, which currently REALLY SUCKS!
 *** shortcuts, an event catch-all, if events propogate past topwindows.
 *** drag n drop (Xdnd, see freedesktop.org?)
 *** cooperate somewhat with various freedesktop.org guidelines
 ***    and/or import and export to how those guidelines say to keep track of things.
 *** readup window classes and imp as per said guidelines
 *** should probably add icon support for those strange window managers that show minimized icons.
 *** xinput support: tablets, joysticks
 *** gl, fontconfig/freetype support?
 *** multiple screen support
 *** be able to ensure some degree of thread safety

 *** WM_ICON_NAME, XGetIconSizes, ...
 *** WM_ICON_SIZE <- usually set by window manager?
 *** urgent hint in XWMHints??
 *** should rearrange anxapp constructor, to allow color size>256. or dynamic changing
 ***    and rework base color setup generally

 *** right now, dialogs can allow or reject Exposes. If allows, the expose sets the needtodraw,
 ***  which sometimes might not be desirable, like if the refresh takes an obnoxious amount of time,
 ***  so should have option of not calling Refresh on non-dialog windows.

 *** if leave a window, then enter again, put focus on what was focuses last
  *** focus handling generally pretty bad.
 *** AFTER_CLICK_FOCUS???

 *** Make Display, Visual, and defaultgc static members? That would simplify a number of things.
 *** provide window circulation functions

 *** register LaxObjects that have a unique id and can send messages between each other.
 This is one step toward a unified event mechanism, just one more thing I was hoping to avoid
 when i started programming this toolkit!! Might
 as well use Fltk!! This type of thing would make integrating things like PanControllers
 and interfaces a little easier perhaps. Such as popping up a FileDialog to get a new filename
 to be used in a strange tool not connected to a window...

 *** think some more about fltk's callbacks and gtkmm signal connecting... could implement something
 sort of similar (see ShortCut/action stuff shortcut.cc)

Class LaxInterfaces::anInterface: *** i'm having difficulty thinking of why this has to be separate from InterfaceWithDp. Haven't particularly needed the plain version.. The plain would only be for generic box clicking and key catching, which can just as easily be done with InterfaceWithDp... might possibly have some code sharing with anXWindow, more thought about this required..

Member LaxInterfaces::anInterface::anInterface (anInterface *nowner, int nid): *** this isn't so hot, maybe do some check to ensure that owner->child points here?

Member Laxkit::anXApp::CreateXInputContext (): for multiple keyboard devices, there would be one xim_ic for each keyboard, since there would be one focus per keyboard

Member Laxkit::anXApp::findDropCandidate (anXWindow *ref, int x, int y, anXWindow **drop): this needs work... especially when there are windows on different screens.. laxkit in general does not handle multiple screens well..

Member Laxkit::anXApp::GetBuffer (): *** this appears to be broken, cannot copy stuff from terminal...

Member Laxkit::anXApp::getlaxrc (const char *filename, const char *profile): might be useful to have ability to grab from multiple profiles? such as have various color profiles, then also font profiles.. use a particular color scheme with a particular font scheme, rather than needing 4 profiles with each combination of color scheme/font scheme? leave that up to particular apps?

Member Laxkit::anXApp::has (int what): *** implement this!

Member Laxkit::anXApp::idle (anXWindow *w): remove this function? is do nothing now

Member Laxkit::anXApp::init (int argc, char **argv): *** this can be further broken down to call specialized functions for each task

Member Laxkit::anXApp::managefocus (anXWindow *ww, XEvent *e): TODO--- ********focus handling is still a bit kooky... ***each top window would have a last currentfocus ***currentfocus not implemented **** WM not sending FocusIn/Out on Enter/Leave, but is changing focus regardless

Member Laxkit::anXApp::processXevent (XEvent *event): **** this screens out cerain events based on what dialogs are up, which is EXTREMELY problamatic...

Member Laxkit::anXApp::reparent (anXWindow *kid, anXWindow *newparent): *** not sure, but there might problem when newparent is a child of kid...

Member Laxkit::anXApp::Resource (LaxFiles::Attribute *resource): might be wise to have reference counted resources, but that's maybe getting too complicated for what these resources are mainly meant for, that is: info used upon dialog creation

Member Laxkit::anXApp::run (): ***main loop mechanism a little broken. doesn't always refresh when no events pending.. need a more effective means to ensure all windows are refreshed before the select() call makes program just sit around.

Member Laxkit::anXApp::run (): have a style for tooltips: be able to make the tooltips variable very small after one gets popped up, then make tooptips large again when a button or key event happens.

Member Laxkit::anXApp::setupdefaultcolors (): ***maybe should switch to color(COLOR_BG), etc.. or color("bg")?? or some other resource system to keep track of first click, directories, bookmarks, etc.

Member Laxkit::anXApp::vis: *** figure out what is necessary tweaking of vis to easily enable opengl integration. little test on my machine allowed gl windows using default vis..

Class Laxkit::anXWindow: make anXWindow RefCounted, this would make much easier inter window communication..

Member Laxkit::anXWindow::close (): is win_parent check really necessary? maybe just rely on ANXWIN_REMEMBER?

Member Laxkit::anXWindow::dump_in_atts (LaxFiles::Attribute *att, int flag): *** ensure that the dimensions read in are in part on screen...

Member Laxkit::anXWindow::dump_out_atts (LaxFiles::Attribute *att, int what): maybe someday have option to overwrite existing attributes in att, but this opens up potential problems due to possible nesting. How deep would the replace function?

Member Laxkit::anXWindow::getSelectionData (int *len, Atom property, Atom targettype, Atom selection): do this without Atoms
this is a little sloppy about types. what if data can be provided not in the given format? need to do SelectionNotify with no data when appropriate. cut/paste implementation is not currently totally ICCCM compliant, but it seems to work at the moment

Member Laxkit::anXWindow::Resize (int nw, int nh): ***i want to remove this one, and only have MoveResize, but when I just have this function call MoveResize, it screws up RowFrame!! what the F? override_redirect funkiness? see icccm 4.2.9

Class LaxFiles::Attribute

*** make sure that line is being freed where necessary...

most of the dump_in_* and dump_out_* could be put in standalone functions which would be more useful

Member LaxFiles::Attribute::dump_in (FILE *f, int Indent, Attribute **stopatsub=NULL): make name==NULL (in file as "") and value=something like "1234\naeuo" behave in some sort of reasonable way, like have name become "" or ~ or something..
*** note that "oauaoe" "aoeuoae" will not parse correctly, will give: "oauaoe" "aoeuoae, when it should actually return the original unchanged

Member LaxFiles::Attribute::dump_in (const char *filename, Attribute *defines=NULL)

*** this function is basically unimplemented.. just opens file, calls the other dump_in. need to implement the defines thingy

*** doesn't do a whole lot of sanity checking on names

*** when dumping in, it is sometimes useful to preserve what the position in the file at which the attribute is written. this would require an extra long variable in Attribute.. For instance for decent error checking, one wants to know where the error occured, but one might still want the ease of dumping in the whole file to an Attribute before parsing values..

Member LaxFiles::Attribute::dump_out_full (FILE *f, int Indent): make name==NULL and value=something like "1234\naeuo" behave in some sort of reasonable way, like have name become "" or ~ or something.. ... null name gets "", but problems still if name has whitespace..

Class LaxInterfaces::BezInterface: be able to restrict to monotonic increasing or decreasing functions, or y=f(x) (every x has 1 y)
smart scanning, only refresh what's necessary? delete final/initial seg fault, delete screwing up control points, shift click: select more than one point, then middle is move just those rather than object movements, showdecs: show only curpoint +- a couple, rather than all control points, *** work out mouse button/drag combos!!! *** need subdivide/other form of cut?, join, scale, rotate, *** when control point on vertex, need "visual" tangent not mathematical, *** deselecting single should occur on mouseup if mouse doesn't move,

Class LaxInterfaces::BezpathOperator

*** work out mouse button/drag combos!!!

*** need subdivide/other form of cut?, join, scale, rotate

*** make circle

Class Laxkit::Button: could combine all the buttons: text button, iconbutton, checkbox into one thing...

Member LaxInterfaces::CaptionData::FindBBox (): *** must be able to find the actual extent of the text! right now, the interface must handle bbox finding.

Class LaxInterfaces::CaptionInterface: this could also be used for little sticky notes in the viewport, these would be text blocks that are not transformed with the viewport's matrix..

Member LaxInterfaces::CaptionInterface::newData (): need some flag somewhere to auto flip vertically (for +y is up rather than down)

Member LaxInterfaces::CaptionInterface::Refresh (): should work this to not need imlib, allowing a redefinable backend to render the text.

Member Laxkit::CheckBox::CheckBox (anXWindow *parnt, const char *ntitle, unsigned long nstyle, int xx, int yy, int ww, int hh, int brder, anXWindow *prev, Window nowner, const char *nsendmes, const char *nname=NULL, int npadx=0, int npady=0): *** clear up setting initial size to be max of graphic height and the text height

Class Laxkit::ColorBox

would be neat to maintain a stack of previous colors?

might be nice to display number in window while dragging..

gray mode

only does cmy<->rgb, not cmyk, which causes rather obnoxious problems..

Member Laxkit::ColorBox::LBDown (int x, int y, unsigned int state, int count): Double click to raise a Color Selection Dialog.

Class LaxInterfaces::ColorPatchData

*** this must be expanded to enable use of somewhat user definable functions for color determination, (see postscript spec for more). also should implement the coons patch as a special case of this.. the coons patch would simply interpolate the inner control points from the outer.

*** the implementation here is rather a mess

Member LaxInterfaces::ColorPatchData::subdivide (int r, double rt, int c, double ct): *** clean me up! simplify me! there is probably an efficient way to extract bits of this and the other subdivide() to shorten the code...

Member LaxInterfaces::ColorPatchInterface::patchpoint (double s1, double t1, double s2, double t2): **** mondo problems with this one, keeps recursing forever

Member LaxInterfaces::ColorPatchInterface::patchpoint2 (): optimize this a la imagepatchinterface....

Member LaxInterfaces::ColorPatchInterface::sendcolor (XRenderColor *col): bit of a hack here.

Class LaxInterfaces::Coordinate: *** perhaps make this ref counting?

Class Laxkit::Displayer

more thought is required about how best to abstract everything to allow different backends such that all the LaxInterfaces classes can use them all.

*** this could be automated a little more, maybe the ruler could watch a panner too? or watch a displayer??? maybe not, rulers are doubles, panners are longs

*** have to coordinate panner->minsel/maxsel and upperbound/lowerbound.

***heell, perhaps combine displayer and panner to DoublePanner? would simplify some things...

***: coordinates grossly outside the X drawable realm potentially cause an X near freeze-up and should not be attempted.

clipping is still a bit of a hack

speaking of clipping, must integrate transparency somehow...

incorporate image/bitmap buffer display routines... should be able to render to basic buffer, not just a Drawable?

Class Laxkit::Displayer: revamp laxkit to use refcounted displayer objects

Member Laxkit::Displayer::drawrellipse (flatpoint p, double xr, double yr, int st=0, int nd=23040): have drawfocusellipse call drawellipse, rather than other way around. put in the fill and isreal options.

Member Laxkit::Displayer::drawbez (flatpoint *bpoints, int n, int isclosed=0, int ndiv=50, int fill=0, int isreal=0): *** implement the fill option.. means have a whole huge points array for whole path rather than just the bez segments.

Member Laxkit::Displayer::LineAttributes (int width, int dash, int cap, int join): should be able to set dash pattern somehow, and set line width based on current transform...

Member Laxkit::Displayer::SetView (double minx, double maxx, double miny, double maxy): *** this needs testing

Member Laxkit::Displayer::clippoints: ***splain how to use it

Member Laxkit::DoubleBBox::intersect (double *m, DoubleBBox *bbox, int touching, int settointersection): *** this is not well implemented, settointersection not implemented.
*** this needs work so that there is option

Member Laxkit::DoubleBBox::intersect (double mix, double max, double miy, double may, int settointersection=0): should me more specific about the kind of intersection: all inside, all outside, or just touching.

Member LaxFiles::DumpUtility::dump_in_atts (Attribute *att, int flag)=0: in future might have a flag somehow to remove atts that are processed (flag=1).. this will have to play nice with dump_in().

Member LaxFiles::DumpUtility::dump_out_atts (Attribute *att, int what): what==-1 should mean write out a definition snippet that represents what attributes can be passed in to this object. this would make it a snap to produce the Attribute equivalent of dtd information..

Class LaxInterfaces::EllipseInterface: *** totally broken, needs some serious rewrite..
*** must be able to fill also?

Member LaxInterfaces::EllipseInterface::InterfaceOn (): *** should push the RectInterface onto the viewport interfaces stack...

Member LaxInterfaces::EllipseInterface::MouseMove (int x, int y, unsigned int state): *** focus move broken!

Member LaxInterfaces::EllipseInterface::scan (int x, int y): *** doesn't pick wild,start,end, picks closest within a distance

Member LaxInterfaces::EllipseInterface::UseThis (Laxkit::anObject *nobj, unsigned int mask=0): **** returns 1 with LineStyle, but does not take over it.. is that ok??

Class Laxkit::FileDialog

FILES_OPEN_ONE still allows multiple to be selected..

*** progressive update when typing file name in file slot. if file is not part of currently selected files, then reset filelist selection. each filelist file selection should update the file slot

***need a special path box to allow easy sanity checking... maybe not even allow editing in path or mask, only in file....or only file and mask

*** should have its own 'Overwrite?' dialog, and optionally return to the file dialog

Member Laxkit::FileDialog::FileDialog (anXWindow *parnt, const char *ntitle, unsigned long nstyle, int xx, int yy, int ww, int hh, int brder, Window nowner, const char *nsend, const char *nfile=NULL, const char *npath=NULL, const char *nmask=NULL, const char *nrecentgroup=NULL): *** need to work out styles, and passing to RowFrame..
include prev?

Member Laxkit::FileDialog::Cd (const char *to): need sanity checking on to.

Member Laxkit::FileDialog::ClearFinalButton (int position): this needs testing

Member Laxkit::FileDialog::ClientEvent (XClientMessageEvent *e, const char *mes): should mask like things in path or file update mask?

Member Laxkit::FileDialog::DataEvent (EventData *data, const char *mes): no sanity checking is done before mkdir(str)

Member Laxkit::FileDialog::getDirectory (const char *npath)

****** wrap this stuff into a FileMenuInfo!!!!!?? how to make the FileMenuItem have path/mask *** and don't forget about scandir!!

*** should return 0 success, nonzero error bad path, etc.

*** this needs much work to use multiple masks...

Member Laxkit::FileDialog::GetState (void **state): ****not necessary? ***would put a NULL terminated char ** list of files in state

Member Laxkit::FileDialog::init (): *** fix quickselect button, it is totally broken at the moment

Member Laxkit::FileDialog::send (int id): if FILES_OPEN_MANY but none selected in the menuselector, defaults to sending a StrEventData rather than a StrsEventData... should probably make it send StrsEventData with one string...?

Class Laxkit::FilePreviewer: ***if text, should be able to toggle between ascii(latin-1)/utf-8, binary hex.

Member Laxkit::FontManager::CheckIn (LaxFont *f): **** this probably isn't necessary? more thought is required about how to handle LaxFont instances..

Class LaxInterfaces::FreehandInterface: ***Currently, this sucks. Should figure out how Sodipodi/inkscape does it.

Class LaxInterfaces::FreehandInterface: ***should be able to add to a current BezData?? ***make choice beteen make LinesData or BezData (or Path?) *** make closed when final point==first point

Member LaxInterfaces::FreehandInterface::MouseMove (int x, int y, unsigned int state): *** this isn't very sophisticated, for elegance, should use some kind of bez curve fitting to cut down on unnecessary points should use a timer so stopping makes sharp corners and closer spaced points?

Member LaxInterfaces::FreehandInterface::Refresh (): *** this is really cheezy, as it just copies bez->Refresh()

Class Laxkit::FuncFrame: *** needs a flag to say need to update sub boxes. else with each resize, all gets recomputed, and for mouse drags, this causes way too much unnecessary computing

Class FunctionData: **** TODO! (or remove imping funtion plotters like this adds lots of code)

Class Laxkit::GoodEditWW: *** lots of stuff, particularly adding scrollers, see class description....

Class Laxkit::GoodEditWW: when switch to utf8 made, will rename this class to MultiLineEdit

Member Laxkit::GoodEditWW::LBDown (int x, int y, unsigned int state, int count): *** should put in drag and drop when lbdown on a selection

Member Laxkit::GoodEditWW::MouseMove (int x, int y, unsigned int state): institute drag and drop for selections

Member Laxkit::GoodEditWW::Replace (const char *oldstr, const char *newstr, int all): *** this, like the others in base classes are wholly inadequate

Member Laxkit::GoodEditWW::ShiftScreen (int x, long y): *** need smart ShiftScreen XCopyArea

Member Laxkit::GoodEditWW::UseTheseScrollers (Scroller *xscroll, Scroller *yscroll): *** this needs work..

Class LaxInterfaces::GradientData

*** move the change between radial and linear to here from GradientInterface? or separate linear from radial.. editing radial is really obnoxious right now..

*** perhaps have the colors array be potentially read only (or make new on change), and be able to be stored elsewhere, thus be able to read stand alone gradient files....

*** care must be taken that final t != initial t (esp is ShiftPoint())!!

it is assumed here that p1<p2, maybe should make that explicit somehow?

Member LaxInterfaces::GradientDataSpot::dump_in (FILE *f, int indent, LaxFiles::Attribute **Att=NULL): *** allow import of Gimp, Inkscape/svg, scribus gradients

Member LaxInterfaces::GradientDataSpot::dump_out (FILE *f, int indent, int what): could have rgba vs. rgba16

Class LaxInterfaces::GradientInterface: figure out how to incorporate color mapping functions..

Member LaxInterfaces::GradientInterface::CharInput (unsigned int ch, const char *buffer, int len, unsigned int state): 'f' should flip or roll (maybe S/s for roll/swap selected points

Member LaxInterfaces::GradientInterface::drawRadial (): this could be rather a lot smarter... like by finding how many XPoints to generate based on the radius of the given circle...

Member LaxInterfaces::GradientInterface::LBDown (int x, int y, unsigned int state, int count): *** shift-click near an already selected but perhaps obscured point should not select the point that is obscuring it instead

Member LaxInterfaces::GradientInterface::Refresh (): the control points should be drawn differently, p1 and p2 should be little triangles that point to each other, and r1 and r2 should point to each other.

Member LaxInterfaces::GradientInterface::SelectPoint (int c): could have state passed in...

Member LaxInterfaces::GradientInterface::sendcolor (XRenderColor *col): bit of a hack here.

Member LaxInterfaces::GradientInterface::UseThis (Laxkit::anObject *newdata, unsigned int): *** must work out what happens when a gradient is passed here. it will not have an object context. should locateObject be used? then viewport->NewCurobj(data,context), or viewer->NewData(data) if data not found?

Class Laxkit::HistoryNode: *** should make this internal to prompt?

Member Laxkit::IconButton::draw (): implement the b+w drawing.

Member Laxkit::IconButton::SetIcon (LaxImage *img, int makebw=0): makebw

Member Laxkit::IconButton::SetIcon (const char *filename, int makebw=0): *** make black and white is not currently implemented.

Class Laxkit::IconSlider: on to striconsliderpopup Gack!!

Member Laxkit::IconSlider::DeleteItem (int id): *** imp me!

Class LaxInterfaces::ImageData

In addition to have filename ande previewimage, perhaps make allowances for a transformedImageCache to facilitate use of ImagePatchData, for instance..... this is relevant because the ImageInterface has lots of drawing code, and it is easier to use a temp ImageData than an ImagePatchInterface, for instance, figuring out how to draw it itself?

Currently depends on imlib2 for clipping reasons, should somehow abstract enough to not rely on it?

should probably have an option for deferred loading? (not needed if using imlib, which basically does that automatically)

have flag: Don't display image|Use original|Use preview?

Member LaxInterfaces::ImageData::UsePreview (const char *npreview, int maxpx=0, int maxpy=0, char del=0): Check that this works as intended.

Member Laxkit::ImageDialog::ImageDialog (anXWindow *parnt, const char *ntitle, unsigned long nstyle, int xx, int yy, int ww, int hh, int brder, anXWindow *prev, Window nowner, const char *nsend, ImageInfo *inf): *** need to work out styles, and passing to RowFrame..

Member Laxkit::ImageDialog::ClientEvent (XClientMessageEvent *e, const char *mes): should probably make the imageinfo fields set to NULL if the corresponding edits return blank strings or strings with only whitespace.

Member Laxkit::ImageDialog::reallyGeneratePreview (): *** need check for fd thumb locations to enforce proper sizing

Class Laxkit::ImageInfo: come to think of it, this could be mostly just a hash, which would make integration of exif info easier...

Class LaxInterfaces::ImageInterface: Ideally, this interface (and indeed all the Laxkit interfaces) would not depend on the LaxImage Backend. Currently, because of clipping problems that I haven't adequately solved, the LaxImlibImage base is required.

Member LaxInterfaces::ImageInterface::duplicate (anInterface *dup=NULL): dup max_preview dims, and make it one dim, not x and y?

Member LaxInterfaces::ImageInterface::newData (): need some flag somewhere to auto flip vertically (for +y is up rather than down)

Member LaxInterfaces::ImageInterface::Refresh (): *** this only can do ImageData whose image is a LaxImlibImage. These interfaces must be able to render to any Xlib drawable, not just a random anXWindow... should probably expand the range of default image out functions.
**** must have check for very expanded images to only draw the section of the image that is actually onscreen, rather than massive image, which nearly freezes X

Member LaxInterfaces::ImageInterface::runImageDialog (): after laxkit event mechanism gets rewritten, the return event would get sent back to this ImageInterface instance, but right now, curwindow has to somehow relay the event to the object in question.

Member LaxInterfaces::ImageInterface::runImageDialog (): *** at some point it might be worth laxkit's while to have a fairly abstracted general object factory, something to be able to say newObject("ImageDialog", (anObject that wants it), other config info)

Class LaxInterfaces::ImagePatchData: *** should have option to offset the color data within the patch!!!

Member LaxInterfaces::ImagePatchData::color (double s, double t)

*** should do transparent also

*** should have flag for orientation

*** should have flag for whether it should be a color ok for x? it ok for 8b per rgb x

Class LaxInterfaces::ImagePatchInterface

for sarge, there's a problem with ImagePatch, for some reason, there are artifacts to window pos 0,0 along one edge.. these do not show on unstable.. also non-24 bit screen depth is faulty

***when inserting new image, should have option to preserve the scale, so if aspect of old image was 2, and new image is 1, then do the same for the aspect of the patch as a whole, or have the image space map to a subset of the patch space, rather than always [0..1]

*** need to incorporate preview images, plus ability to add transfrom to image within patch..

Member LaxInterfaces::ImagePatchInterface::drawpatch (int roff, int coff): *** when there is no image should do something clever to indicate there is none, like drawing a bezier X across the patch.

Member LaxInterfaces::ImagePatchInterface::patchpoint (double s0, double ds, double t0, double dt, int n): *** optimize this baby! If going beyond resolution of what is in the color source, should be able back up and draw larger rect...

Member LaxInterfaces::ImagePatchInterface::renderToBuffer (unsigned char *buffer, double *m, int width, int height): *** this is EXTREMELY innefficient

Member LaxInterfaces::ImagePatchInterface::rpatchpoint (flatpoint ul, flatpoint ur, flatpoint ll, flatpoint lr, double s1, double t1, double s2, double t2, int which): *** this needs some serious optimizing. it is currently in the HEINOUS HACK stage right now.. maybe faster with floats?

Member LaxInterfaces::ImagePatchInterface::runImageDialog (): *** after laxkit event mechanism gets rewritten, the return event would get sent back to this ImageInterface instance, but right now, curwindow has to somehow relay the event to the object in question.

Member Laxkit::InputDialog::ClientEvent (XClientMessageEvent *e, const char *mes): *** enter from the lineedit makes focus jump to ok button?

Class LaxInterfaces::InterfaceWithDp: *** for UseThis(), what happens when an object that is an interface's data type is passed in? should context be searched for, and viewport->NewCurobj called? viewport->NewData()?

Member LaxInterfaces::InterfaceWithDp::Curdata (): *** is this is really necessary!!?

Class Laxkit::ItemSlider: *** perhaps add basic popup mechanism to this class?

Member Laxkit::ItemSlider::Idle (int tid=0): *** need to implement fast scrolling with shift/control!!

Class Laxkit::LaxFont: read up on Xft, and (?) FontSets, have ability to maintain charwidths[] for multiple ranges, not just the basic Latin1/small [firstcharinfont + numcharsinfont]. Must be able to facilitate font subsetting
needs serious cleanup, right now is mixed core xlib and xft. Brrrr!

Member Laxkit::LaxFont::charwidth (unsigned long chr, int real): *** this is broken

Member Laxkit::LaxFont::contextcharwidth (char *start, char *pos, int real): This function as it stands is totally worthless and meaningless.

Member Laxkit::LaxFont::SetupMetrics (): *** this is old and basically broken. is all core xlib

Class Laxkit::LaxImage: *** need flag or something to say if it is the preview or the main image in memory.
dataw() and datah() should be renamed pw() and ph(), plus might be useful to have a imagew() and imageh() for the dims of the thing that image points to.

Member Laxkit::LaxImage::~LaxImage (): *** perhaps unlink also only if dataw()>0? not sure if that is accessible in destructor, might have to intercept dec_count().

Member Laxkit::LaxImlibImage::LaxImlibImage (const char *fname, Imlib_Image img=0, const char *npreviewfile=NULL, int maxx=0, int maxy=0, char del=1)

*** needs to be some error checking when generating new previews

scaling to maxx OR maxy if either 0 not implemented. both must currently be nonzero.

when generating preview, might be wise to have check for freedesktop thumb locations to enforce proper sizing

Member Laxkit::LaxImlibImage::Image (int which=0): note that if image is already loaded, this function does not yet switch to the proper one..

Class Laxkit::LineEdit

LINEEDIT_POPUP==LINEEDIT_DESTROY_ON_FOCUS_OFF|DESTROY_ON_SEND|LINEEDIT_GRAB_ON_MAP for things like menuselector edit in place, or strinputslider

*** non actual moves must deselect selection

***undo??? or be able to do 'esc' to revert to what edit was before focus?

*** RBDown should shift screen

*** maybe put in margins+pad

you know, this could be abstracted so the underlying text functions of TextEditBase and TextXEditBase could be an object rather than a parent class.. would make swapping out the back end easier, so wouldn't have to rewrite the interface from scratch each time.. thinking of using pango, also what about interface tools that use text? have to rewrite the whole character input mechanism again?!?

Class Laxkit::LineEdit: *** implement LINEEDIT_INT and _FLOAT

Member Laxkit::LineEdit::CharInput (unsigned int ch, const char *buffer, int len, unsigned int state): ESC for reset to a copy of initial buffer

Member Laxkit::LineEdit::LBDown (int x, int y, unsigned int state, int count): make finding position go to closest char division, not always to beginning of char

Member Laxkit::LineEdit::Modified (int m=1): finish implementing this..

Member Laxkit::LineEdit::Replace (char *newstr, char *what, int all): finish me!

Class Laxkit::LineEditLatin1

LINEEDIT_POPUP==LINEEDIT_DESTROY_ON_FOCUS_OFF, DESTROY_ON_SEND, LINEEDIT_GRAB_ON_MAP for things like menuselector edit in place, or strinputslider

*** non actual moves must deselect selection

***undo??? or be able to do 'esc' to revert to what edit was before focus?

*** RBDown should shift screen

*** maybe put in margins+pad

*** change modified to Modified()

Class Laxkit::LineEditLatin1: *** implement LINEEDIT_INT and _FLOAT

Member Laxkit::LineEditLatin1::CharInput (unsigned int ch, const char *buffer, int len, unsigned int state): ESC for reset to a copy of initial buffer

Class Laxkit::LineInput: *** fix crash on NULL label...

Member Laxkit::LineInput::FocusOn (XFocusChangeEvent *e): *** transfer focus to le

Class LaxInterfaces::LinesInterface: this is really old code and needs a good going over

Member LaxInterfaces::LinesInterface::UseThis (Laxkit::anObject *newdata, unsigned int mask=0): does viewport->NewData(newdata).. maybe newdata exists in it already?

Class LaxInterfaces::LineStyle: int width; *** including invisible vs. hairline (==0)
*** complete conversion to using XRenderColor?

Class Laxkit::LinkedList< T >: ***** this needs testing

Class Laxkit::MenuButton: should probably refcount menuinfos

Class Laxkit::MenuInfo: *** RemoveItem

Class Laxkit::MenuSelector: *** need style USE_ALL_OPEN, where all open submenus are used, should also be able to toggle wether the actual item text is displayed when the sub stuff is used: or put that in a TreeSelector?? item -item- <--item has open sub menu, the submenu's title is ignored sub1 -sub2- <--sub2 has open sub menu, the submenu's title is ignored subsub1 subsub1

Class Laxkit::MenuSelector: *** implement hidden items

Class Laxkit::MenuSelector: a lot of stuff, see class MenuSelector

Member Laxkit::MenuSelector::AddItems (const char **i, int n, int startid): ***this is cheap, should be optimized for large arrays?? add in one lump, then sort??

Member Laxkit::MenuSelector::arrangeItems (int forwrapping=0): ***Need to implement FIT_TO_WIDTH, or remove is as possibility...

Member Laxkit::MenuSelector::drawitem (MenuItem *mitem, XRectangle *itemspot): *** Highlighting should go right across the item, behind any other doodads put up, currently just goes across text...

Member Laxkit::MenuSelector::drawitem (MenuItem *mitem, XRectangle *itemspot): *** set clip to intersection of itemspot and inrect??

Member Laxkit::MenuSelector::drawsubindicator (MenuItem *mitem, int x, int y): for MENUSEL_SUB_FOLDER, draw an open or closed folder.

Member Laxkit::MenuSelector::editInPlace (): *** imp me!

Member Laxkit::MenuSelector::getgraphicextent (MenuItem *mitem, int *x, int *y): *** incorporate icons/XImages/Pixmaps.. wait to do this until laxkit has more definite image handling setup

Member Laxkit::MenuSelector::Idle (int tid): *** must autoscroll when mouse over arrow and FOLLOW_MOUSE

Member Laxkit::MenuSelector::item (int i, char skipcache=0): maybe have option to force remapping==bypassing any search cache??

Member Laxkit::MenuSelector::LBUp (int x, int y, unsigned int state): *** lbdown/up no drag on an already selected item should initiate EDIT_IN_PLACE

Member Laxkit::MenuSelector::LBUp (int x, int y, unsigned int state): *** mousedragged==2 means a rearrangement might be required

Member Laxkit::MenuSelector::MouseMove (int x, int y, unsigned int state): *** should implement speedy shifting with shift/cntl-RB drag

Member Laxkit::MenuSelector::MouseMove (int x, int y, unsigned int state): *** also, if right-click shifting, and is off screen, do a sort of auto scrolling, like if mouse above, then move if mouse moving up, but not if mouse is moving down?? or on timer?

Member Laxkit::MenuSelector::RBDown (int x, int y, unsigned int state, int count): ***perhaps someday have a hook so that right click on an item calls up some menu? like copy to, delete item, etc..

Member Laxkit::MenuSelector::Select (int which): *** add state to it, for more control... that is be able to modify state of any element...

Member Laxkit::MenuSelector::send (): *** there needs to be option to send id or list of ids..

Member Laxkit::MenuSelector::SetFirst (int which, int x, int y): *** no bounds check, should at least make sure something is in window?

Member Laxkit::MenuSelector::SetFirst (int which, int x, int y): *** fix me!

Member Laxkit::MenuSelector::Sort (int t): *** should be able to sort only a subset, for instance all items between separators.

Member Laxkit::MenuSelector::WrapToMouse (Window onedgeofthis=None): *** BROKEN! fix me!

Member Laxkit::MenuSelector::firstinw: *** should remove this variable, i don't think it is needed

Class Laxkit::MessageBar

*** need to implement wrapping style

*** SetText(char *s1,char *s2, ...)

Member Laxkit::MessageBar::SetText (const char *newtext): this can use split()

Class Laxkit::MessageBox: standard buttons like OK or Cancel! or whole style like
Overwrite? Yes No Cancel
Save "blah"? Yes No Cancel
Save "blah" before quitting? Yes No
"blah" unsaved, quit anyway? Yes No

Class Laxkit::MessageBox: *** incorporate automatic Control Tab Loop thingy ***first button is always ok?? *** must have a constructor specifically for blocking popups that auto-wrap to message extent, and send a message back

Member Laxkit::MessageBox::MessageBox (anXWindow *parnt, const char *ntitle, unsigned long nstyle, int xx, int yy, int ww, int hh, int brder, anXWindow *prev, Window nowner, const char *nsend, const char *mes): prev is ignored

Member Laxkit::MessageBox::preinit (): ***check this!!

Member Laxkit::MessageBox::preinit (): this needs a little more thought....

Class Laxkit::MultiLineEdit: *** lots of stuff, particularly adding scrollers, see class description....

Member Laxkit::MultiLineEdit::ClientEvent (XClientMessageEvent *e, const char *mes): *** not sure if this is ok since scrollers use the panner now...

Member Laxkit::MultiLineEdit::LBDown (int x, int y, unsigned int state, int count): *** should put in drag and drop when lbdown on a selection

Member Laxkit::MultiLineEdit::MouseMove (int x, int y, unsigned int state): institute drag and drop for selections

Member Laxkit::MultiLineEdit::Replace (const char *oldstr, const char *newstr, int all): *** this, like the others in base classes are wholly inadequate

Member Laxkit::MultiLineEdit::SetupScreen (): *** if (xscroller && xscroller->win_on) xscroller->MoveResize(0,win_h-scrollwidth, win_w,scrollwidth);
*** if (yscroller && yscroller->win_on) yscroller->MoveResize(win_w-scrollwidth,0, scrollwidth,win_h);

Member Laxkit::MultiLineEdit::ShiftScreen (int x, long y): *** need smart ShiftScreen XCopyArea

Member Laxkit::MultiLineEdit::UseTheseScrollers (Scroller *xscroll, Scroller *yscroll): *** this needs work..

Member Laxkit::MultiLineEdit::wwinspect (int fromline=0): *** perhaps an optimization would be wwinspect(fromline,scanAtLeastThisManyLines)

Class Laxkit::NumInputSlider: Double click should also jump to edit. A single normal click will inc or dec the value, and the double click should revert to previous value before entering the edit.

Class Laxkit::NumSlider: optional label: [ Blah: 34 ]
super shift/ shift-but4 to move faster*** put that in itemslider

Member Laxkit::NumSlider::Refresh (): *** show a faint arrow to say what will happen when you click on where mouse is hovering

Member Laxkit::NumStack::pushnodup (T nd): should probably have -2 for error, though currently no errors are caught.

Class LaxInterfaces::ObjectInterface: ********* must have mechanism to get viewport events like layer up, home, end, etc, to affect all in selection!!

Member LaxInterfaces::ObjectInterface::AddToSelection (ObjectContext *oc): make it easier for subclasses to use this function, and also store/copy the object context

Member LaxInterfaces::ObjectInterface::GrabSelection (unsigned int state): *** imp me with something more useful!!
have flag for select inrect or touchingrect

Member LaxInterfaces::ObjectInterface::LBDown (int x, int y, unsigned int state, int count): Double click ought to switch to the objects proper tool.

Member LaxInterfaces::ObjectInterface::MouseMove (int x, int y, unsigned int state): *** preserve aspect on a shift-resize

Class Laxkit::Palette: *** needs better color management, have color space field, etc....

Member Laxkit::PaletteWindow::LoadPalette (const char *file): *** check readability of the file...
*** make a default palette for file==NULL 32x8 rainbow

Member Laxkit::PaletteWindow::MouseMove (int x, int y, unsigned int state): this could be used to show a temp color? buttondown-nodrag-up actually changes curcolor?

Member Laxkit::PaletteWindow::send (): *** of course, these palettes are not quite up to the task of sending non-rgba colors. right now sends the max color value, then up to the first 4 channels. If fewer than 4 channels, then the other xclient datas are filled with 0;

Member Laxkit::PanController::sendMessages (): *** rather than sending messages, could be really clever and just set needtodraw=1 on the tellstack windows!! wouldn't need to define whole new function then, much nicer!
*** send indication of what has changed? keep a XEvent struct filled with various settings, 1=x move change, 2=move ychange, 3=x selsize change, x wholesizechange, etc...

Member LaxInterfaces::PatchData::FindBBox (): ***this currently only does bounds for control points

Member LaxInterfaces::PatchData::inSubPatch (flatpoint p, int *r_ret, int *c_ret, double *t_ret, double *s_ret, double d): *** could have inSubPatchBBox, to more easily search for point over a control point

Member LaxInterfaces::PatchData::subdivide (int r, double rt, int c, double ct): *** clean me up! simplify me! there is probably an efficient way to extract bits of this and the other subdivide() to shorten the code...

Member LaxInterfaces::PatchData::zap (): generally for somedatas, perhaps shouldn't really FindBBox() all the time, but instead do it on a check for modified, so as to not find bbox at every change?

Class LaxInterfaces::PatchInterface: *** add warping controls, such as control how to warp to circle, 3x3 matrix warp. maybe add some kind of generic TransformInterface to allow skewing,flipping of selected points
*** This does not implement the free form patch setup found in Postscript. that functionality might go in a separate class, as the needs are a little too different perhaps.

Member LaxInterfaces::PatchInterface::CharInput (unsigned int ch, const char *buffer, int len, unsigned int state): *** l/r/u/d to shift selected points: plain-move rolls curpoints, shift-move adds to curpoints, control-move rolls without wraparound
whichcontrols or data->controls?

Member LaxInterfaces::PatchInterface::drawControlPoints (): in the future someday, might be useful to only show control points for "active" subpatches, or when shift-hovering

Member LaxInterfaces::PatchInterface::InterpolateControls ()

might be useful to be able to override whichcontrols here..

this could be optimized..

*** move this to PatchData

Member LaxInterfaces::PatchInterface::MouseMove (int x, int y, unsigned int state): revamp controls: plain click in, not on point, be like image

Member LaxInterfaces::PatchInterface::Refresh (): *** maybe should break off drawing of various decorations to other functions, so for instance, the colorpatch can draw controls as little color bubbles, which is much more useful when in "outline" mode, if that ever gets implemented

Class LaxInterfaces::PathInterface

*** adding points is currently really crappy, there's a mixup with mouse down on line and mouse down inside bbox.....

PathInterface should be able to draw single Path objects, not just PathsData?

*** need to implement some sort of svg path parser and outputer. these could be separate functions, since it would try to create a path potentially with ellipses, bezier segments, and straight lines, but PathInterface itself should not have to know about bez and ellipses..

***TODO: should separate this into a PathWorker, PathDrawer, and a PathInterface. PathWorker would be globally available, rather than wrapped in the interface. This would make random construction of paths much easier, and make it unnecessary to fill each interface with separate pathops each time an interface is instantiated. --OR-- have static base PathOperator stack, and each new PathInterface instance instantiates itself from that stack... this is better...

*** unknown PathOperators are marked with straight line between vertices with a question mark at middle

*** MUST make sure that PathsData/Path heads are all vertices. That makes dealing with breakpoints easier

*** how to make these undoable, or just nondestructive as in blender?

*** must incorporate shift-move on grid lines, angles on 0/90/45/30/60/custom, etc.

*** operations like make circle, arrange, flip, etc?

*** constrain x/y

*** PathInterface:: find BBox????

*** not displaying circles for vertex points of lines after bez points

Class LaxInterfaces::PathInterface: *** decoration drawing

Member LaxInterfaces::PathOperator::newPoint (flatpoint p, char prefunit=0, char *retunit=NULL)=0: *** also return which point should be currently selected!

Member LaxInterfaces::PathsData::FindBBox (): add support provided by PathInterface::basepathops

Class Laxkit::PopupMenu

***** mondo needs work!!!!!!!!!! *** problem when menu is popped up from a running dialog, crossing over between the popped menus makes all events be blocked!!!

add support for tearoff menus

Class Laxkit::PrintDialog: Need a CancelPrint dialog class, initiated when printing commences...

Class Laxkit::PrintDialog: save a printing context in a special laxrc type of place, or directly in ~/.lpoptions

Member Laxkit::PrintDialog::PrintDialog (anXWindow *parnt, const char *ntitle, unsigned long nstyle, int xx, int yy, int ww, int hh, int brder, anXWindow *prev, Window nowner, const char *nsend, const char *nfiletoprint=NULL, PrintContext *pt=NULL): *** need another constructor where you just pass an lpoption instance?

Member Laxkit::PrintDialog::send (): maybe send note says sent to printer with job number?

Class Laxkit::ProgressBar: *** have optional label and call function which would check just for pending map/unmap events, then Refresh().

Member Laxkit::ProgressBar::ProgressBar (anXWindow *parnt, const char *ntitle, unsigned long nstyle, int xx, int yy, int ww, int hh, int brder): ***should add bounds, colors to the constructor!

Class Laxkit::PromptEdit: tab completion

Member Laxkit::PromptEdit::CharInput (unsigned int ch, const char *buffer, int len, unsigned int state)

*** clear to start of command line

*** clear to end of command line

*** clear whole command line

*** other readline-y things like searching? tab completion?

Member LaxInterfaces::RectData::~RectData (): decide whether to even have a linestyle in here.

Class LaxInterfaces::RectInterface

********* there appears to be a bit of memory corruption somewhere. frequently, data->griddivisions gets a crazy value...

*** update docs here!

*** differentiate move preserve aspect, and move with aspect==1 (as square) ***draw only whats necessary ***general debug, ISSQUARE *** a style to allow movement only, not resize, except on cntl??? VISIBLECENTER still allows a center for rotations if center is on a control point, be able to sequentially select point(s) beneath

*** should probably have a style where you just section off a plain, non rotated rectangle with no control points indicated. like for cropping

*** need mode to distinguish between modifying the min/max bounds, and modifying the matrix. When the matrix is adjusted so that w==0 or h==0, there are special problems to check for!! causes matrix to be degenerate...

Member LaxInterfaces::RectInterface::MouseMove (int x, int y, unsigned int state): *** preserve aspect on a shift-resize

Member LaxInterfaces::RectInterface::UseThis (Laxkit::anObject *newdata, unsigned int): *** figure out how this jives with viewport window, especially when this is working on the same data that another interface is working on.. often this will be a child of another interface...

Class Laxkit::RowColBox: *** need to debug laying out where boxes put in fixed width, but the whole height wraps to the vertical extent of the child boxes

Class Laxkit::RowColBox: *** would be nice to auto layout in multiple columns if the boxes allow it.

Class Laxkit::RowColBox: *** need to incorporate internal creation of sub-rows and columns... maybe that should only be done in subclasses? it is easy enough to push a new SquishyBox, but classes like RowFrame have special needs..

Member Laxkit::RowColBox::arrangeBoxes (int distributetoo=0): *** should implement all 8 LRTB, LRBT, ... Currently horizontal is only LRTB, and vertical is only TBLR.

Class Laxkit::RowFrame

make more clear all the layout options and padding, as well as implement them!!

***beware when deleting child windows, squishybox stack becomes out of sync, it may have pointers to windows that have been delete'd already... maybe redefine deletekids to detect that?

Member Laxkit::RowFrame::RowFrame (anXWindow *parnt, const char *ntitle, unsigned long nstyle, int xx, int yy, int ww, int hh, int brder, anXWindow *prev, Window owner, const char *mes, int npad=0): Deal with ROWFRAME_LAYOUT_MASK and LRTB, etc better...

Member Laxkit::RowFrame::Resize (int nw, int nh): *** NEED to cache sync requests, not do them right out!!! currently, if big arrangements, several resize events close together produce monstrously slow refreshing..

Member Laxkit::RowFrame::arrangedstate: see about not duplicating this from RowColBox

Class Laxkit::RulerWindow

*** wrote this class LONG long ago, now trying to figure out just what I was doing...

*** placeable range indicators

*** must be able to move position when mouse is in this window!!!

***make vertical writing on the vertical ruler

***could make ruler automatically track mouse with mouseposition() every 10ms or so or respond to sent mouse move messages, and mouseposition() to get location...

*** have y be positive in up direction

Class Laxkit::RulerWindow: *** default tick placement is currently very ugly, need better spacing

Member Laxkit::RulerWindow::drawtext (double n, int &textpos, int toff): *** this could use some work, particularly, vertical rulers should employ vertical text

Member Laxkit::RulerWindow::Track (): *** this is unimplemented

Class Laxkit::ScrolledWindow: *** should have option to either resize thewindow to fit within the space not taken by scrollers, and pass on panchange events to that window, OR have thewindow be just a huge window that the scrollbars automatically move around!!! That would be quite useful for containing dialogs....

Member Laxkit::ScrolledWindow::ClientEvent (XClientMessageEvent *e, const char *mes): *** this must respond to panner events and pass them on to the subwindows...

Member Laxkit::ScrolledWindow::syncWindows (int useinrect=0): parameter useinrect is not used, in fact, i can't remember what I put it there for... maybe it'll come back to me..

Member Laxkit::ScrolledWindow::syncWindows (int useinrect=0): *** window shifting rather than relay messages is not implemented yet

Class Laxkit::Scroller

*** all this assumes max>min, should allow min>max?? flip(pos) { return max-(pos-min); }

*** watch out for ALLOW_SMALL

Member Laxkit::SimplePrint::ClientEvent (XClientMessageEvent *e, const char *mes): Changes to printstart and end use the c function atoi() and do not check for things like "1ouaoeao" which it sees as 1.

Member Laxkit::SimplePrint::Print (): *** printthis!=NULL needs testing/debugging

Class Laxkit::SliderPopup: ******** needs work! update these docs

Class Laxkit::SliderPopup: Make optional tab-completing input similar to NumInputSlider, perhaps in a subclass.

Member Laxkit::SliderPopup::LBDown (int x, int y, unsigned int state, int count): *** work out how transfer focus

Member Laxkit::SliderPopup::send (): if (win_style&SLIDER_SEND_STRING) send StrEventData

Member Laxkit::SliderPopup::WrapToExtent (): *** this only works before mapping because it sets win_w,win_h directly, rather than through Resize().. should probably think if this is good or not.

Class Laxkit::SplitWindow

*** Resizing should be redone, it is not reversible owning to integer rounding errors. perhaps have PlainWinBox have float x,y,w,h to shadow the windows actual values? or just finish imping validateX() and validateY()

*** maximize/minimize with alt-numpad-/ or some such

*** implement optional stack of windows for each pane. each is accessible how(??? tabbed window? through menu), then have option to spread out the stack into separate boxes?

Member Laxkit::SplitWindow::Add (anXWindow *win, unsigned int whichside=LAX_BOTTOM): *** TODO: If lots of adding goes on before creating the window, or just after creating when the dimensions are meaningless, should have some mechanism to keep the stacking order when the windows are scaled properly!! have a flag that gets turned off in init?
*** when head->window==0 and win is parented elsewhere, does this work correctly?

Member Laxkit::SplitWindow::GetAffected (int x, int y): *** this should probably be redone to not be very dependent on space. that would allow recovering from resizing to really small windows easier..

Member Laxkit::SplitWindow::GetMenu (): *** swap with....

Member Laxkit::SplitWindow::Join (int c, int whichside, char keepother=0): *** test this

Member Laxkit::SplitWindow::joinwindow (int x, int y, char keepother): *** when windows are joined, what happens to the vanquished one? store it in limbo?

Member Laxkit::SplitWindow::LBDown (int x, int y, unsigned int state, int count): Straight clicking starts a move on the whole continuous segment. would be neat if double clicking moved only the primary windows.

Member Laxkit::SplitWindow::NewWindow (const char *wtype, anXWindow *likethis=NULL): **** implement the SPLIT_*!!!!

Member Laxkit::SplitWindow::RBDown (int x, int y, unsigned int state, int count): *** should only pop a menu if in a blank pane or in gutter.. this is because uncaught mouse events are propagated in anXWindow...

Member Laxkit::SplitWindow::RemoveCurbox (): if the pane span is such that several windows might be expanded to cover it, then do that, rather than demand that 1 window can join to it.. The super fancy version would somehow figure out how to fill the void if no join is available (like a tatami mat)

Member Laxkit::SplitWindow::SetSpace (int spc): this needs checking so that skinny windows do not get negative width/height

Member Laxkit::SplitWindow::Split (int c, int whichside, anXWindow *fillwindow=NULL): *** test this

Member Laxkit::SplitWindow::validateX (): ***

Member Laxkit::SplitWindow::validateY (): ***

Class Laxkit::SquishyBox: *** implement fpen

Class Laxkit::SquishyBox: *** add simple penalties also, not just box and glue. this would allow fuller control over layouts: force break, no break, and ok to break or not

Class Laxkit::StrIconSelector: on off mover-on mover-off grayed *** must have a make_gray_pixmap *** MUST coordinate all the states in various controls to use new LAX_* defines

Member Laxkit::StrSliderPopup::LBDown (int x, int y, unsigned int state, int count): *** work out how transfer focus

Member Laxkit::TabFrame::Refresh (): implement draw tab outlines style (like folder tabs), rather than default button style (a bevel)

Member Laxkit::TabFrame::SelectN (int which): rearrange rows when a tab has to be brought forward!!

Class Laxkit::TableBox: ***please note that this class is totally unimplemented.

Class Laxkit::TextEditBase: ***finish putting in Modified() to whatever modifies!!! implement max/min textlen/numlines

Member Laxkit::TextEditBase::Replace (const char *newstr, const char *, int which): *** this is wholely inadequate

Member Laxkit::TextEditBase::WhichLine (long pos): *** perhaps remove this from this class, it is not used here, and a 'line' is perhaps too much a many splendored thing.

Class Laxkit::TextEditBaseUtf8

might be good idea to somehow define the encoding? Latin-1, utf8, ascii? probably much more hassle than it's worth.. simpler to do all in utf8.

*** thinks all utf8 chars are actually distinct chars... is this true? are some utf8 actually tags for vowel marks over a previous char? at times like these, pango is looking pretty good..

implement max/min textlen/numlines

Class Laxkit::TextEditBaseUtf8: ***finish putting in Modified() to whatever modifies!!!

Member Laxkit::TextEditBaseUtf8::Find (const char *str, int fromcurs=1): *** should optionally do case insensitive search

Member Laxkit::TextEditBaseUtf8::insstring (const char *blah, int after=0): should probably validate blah. currently it is assumed that blah is valid utf8.

Member Laxkit::TextEditBaseUtf8::Replace (const char *newstr, const char *, int which): *** this is basically unimplemented currently

Member Laxkit::TextEditBaseUtf8::WhichLine (long pos): *** perhaps remove this from this class, it is not used here, and a 'line' is perhaps too much a many splendored thing. besides as implemented here is very inefficient.

Member Laxkit::TextXEditBase::Copy (): *** figure out what's wrong with the copy/paste stuff.. should be able to copy right from the terminal, but that's not working..

Member Laxkit::TextXEditBase::FocusOff (XFocusChangeEvent *e): perhaps should also color the selection differently.

Member Laxkit::TextXEditBase::GetFont (): *** this is SO broken.

Class Laxkit::TextXEditBaseUtf8

*** a utf8 must have different simple get extent for compound characters???

how best to standardize text controls?

maybe have app held color styles...

*** snafus with really long lines

*** makeinwindow if it can fit, it should fit

*** map space to tab for TABS_SPACES in charwidth(), tabwidth=' '*4

*** color in the pad space, put little bevel, etc

*** NO_TAB

*** paste nl conversion

*** DrawLineOfText should use a maxpix and a maxpos for refreshing and word wrapping convenience respectively

Member Laxkit::TextXEditBaseUtf8::Copy (): *** figure out what's wrong with the copy/paste stuff.. should be able to copy right from the terminal, but that's not working..

Member Laxkit::TextXEditBaseUtf8::DrawLineOfText (int x, int y, long pos, long len, char &check, long eof=-1): *** automatically blacks out x to eol, is this ok?

Member Laxkit::TextXEditBaseUtf8::FocusOff (XFocusChangeEvent *e): perhaps should also color the selection differently.

Member Laxkit::TextXEditBaseUtf8::GetExtent (long pos, long end, int lsofar=0, long eof=-1): *** must fix the not taking into account missing chars..

Member Laxkit::TextXEditBaseUtf8::GetPos (long pos, int pix, int lsofar=0, long eof=-1): mishandles missing chars

Member Laxkit::TextXEditBaseUtf8::TextOut (int x, int y, char *str, long len, long eof): break off the actual string output to laxutils::textout()?

Class Laxkit::TimerInfo: *** maybe use info field set to which button pressed, if it was a mouse timer, for instance, then have app check when the button is up, and remove the timer then?

Class Laxkit::ToolTip: *** use utf8 strings..

Class LaxInterfaces::ViewerWindow

It would be nice to have the scrollers/rulers/other in some sort of separate container, independent of the interface system... ScrolledWindow just has scrollers, not rulers.

rulers should always extend over whole viewport. Scrollers don't really have to.

have AddToTop/Bottom(other window, etc), AddToLeft/Right, which would sqeeze in other little windows where the scrollers are.

might be useful to have function to change the viewport at any time.

Member LaxInterfaces::ViewerWindow::init (): *** app->addwindow(viewport) is called here, which might be a little silly.

Class LaxInterfaces::ViewportWindow

possibly make VIEWPORT_DOUBLEBUFFER an option for anXWindow

***should have message to parent ViewWindow when curobj changes, so that ViewWindow can then notify all its little tracker windows.

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.

Member LaxInterfaces::ViewportWindow::ChangeObject (SomeData *d, ObjectContext *oc): *** 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.

Member LaxInterfaces::ViewportWindow::DeleteObject (): *** must more clearly standardize curobj treatment, and how curobj->clear() should function

Member LaxInterfaces::ViewportWindow::FindObject (int x, int y, const char *dtype, SomeData *exclude, int start, ObjectContext **oc): *** this needs a little more clarification...

Member LaxInterfaces::ViewportWindow::FindObjects (Laxkit::DoubleBBox *box, char real, char ascurobj, SomeData ***data_ret, ObjectContext ***c_ret): need flag for IN box or just TOUCHING box

Member LaxInterfaces::ViewportWindow::LBDown (int x, int y, unsigned int state, int count): *** 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...?

Member LaxInterfaces::ViewportWindow::MBDown (int x, int y, unsigned int state, int count): *** 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

Member LaxInterfaces::ViewportWindow::NewCurobj (SomeData *d, ObjectContext **oc=NULL): *** why still have d and oc? perhaps have d be an interface specific data, and oc then is NULL? is that useful I wonder?

Member LaxInterfaces::ViewportWindow::postmessage (const char *mes): *** implement a printf-ish postmessage("format string %d",i,....)

Member LaxInterfaces::ViewportWindow::SetSpace (double minx, double maxx, double miny, double maxy): *** return value? success? on change?

Member LaxInterfaces::ViewportWindow::curobj: *** more thought is required here... could just keep it all internal, still have to iron out interfaces searching for objects and ObjectInterface.

Class LaxInterfaces::ViewportWithStack: *** occasionally might be useful to have the list of objects be external..

Member LaxInterfaces::ViewportWithStack::ClientEvent (XClientMessageEvent *e, const char *mes): *** should respond to an updateCurcolor, which interfaces can send when a new point is selected, for instance.

Member Laxkit::filterkeysym (KeySym keysym, unsigned int *state): If the keysym corresponds to any of the keys in laxdefs.h, then it is mapped to those values. Otherwise...? CharInput() says if the returned value is > 0x1000000, then it is either a Laxkit value, or the X keysym plus 0x1000000, which is not quite how it is coded right now. need to check if the keysym can still be converted to a unicode value. keysyms correspond pretty well to it, and should have been converted to the buffer is event() if so, but not sure of that.

Member LaxFiles::AttributeToXML (Attribute *att, char *&appendtothis): implement me!

Member LaxFiles::AttributeToXMLFile (FILE *f, Attribute *att, int indent)

perhaps have a niceness parameter, so to lay out XML attributes inside a tag on separate lines: <blah first="1" ="" second="2">

comments not handled correctly

*** this needs a lot of work for escaped quoted stuff....

Member LaxFiles::dump_out_escaped (FILE *f, const char *str, int n): *** quote on escaped, quote on any ws, quote on initial or trailing ws, never quote, quote on escaped or ws, always quote
*** Currently assumes no newlines... could substitute '\n' for them...

Member LaxFiles::dump_out_value (FILE *f, int indent, const char *value): note that this will almost always quote value, and it probably shouldn't for simple values

Member LaxFiles::IntAttribute (const char *v, int *i, char **endptr): warning, this will parse "200jjj" as 200, and return 1.

Member LaxFiles::IntListAttribute (const char *v, int **i, int *n_ret, char **endptr): *** need to do some testing on this

Member LaxFiles::NameValueAttribute (const char *str, char **name, char **value, char **end_ptr, char assign, char delim, const char *stopat): imp delim!!

Member LaxFiles::QuotedAttribute (const char *v, char **endptr): ****** on error, what happens to endptr?
**** all of v is copied right at the beginning, wasting much memory, should just crawl along v, copying chars to a smaller buf, reallocating that if necessary?

Member LaxFiles::TransformAttribute (const char *v, double *m, char **endptr): *** implement me!

Member LaxFiles::XMLChunkToAttribute (Attribute *att, const char *buf, long n, long *C, const char *until, const char **stand_alone_tag_list)

UNLESS there are only non-tagged characters between the tags. In that case, the text becomes the value of the given tag.

WARNING!! something like in html where img, br, hr, etc do not have closing tags are not dealt with properly... need to flesh out stand_alone_tag_list

this should be thoroughly gone over by someone who actually knows something about XML in current state is rather sloppy, and is just barely enough to be useful in most cases I've dealt with recently...

*** doesn't handle comments

Member LaxFiles::XMLChunkToAttribute (Attribute *att, const char *buf, long n, long *C, const char *until, const char **stand_alone_tag_list): should have case sensitive switch

Member LaxFiles::XMLChunkToAttribute (Attribute *att, FILE *f, const char **stand_alone_tag_list): this just reads in the whole file to memory then parses it, which might be rather inefficient, but it is easy to code..
must interpret !DOCTYPE and ?xml...? correctly...

Member LaxFiles::XMLFileToAttribute (Attribute *att, const char *file, const char **stand_alone_tag_list): WARNING!! something like in html where img, br, hr, etc do not have closing tags are not dealt with properly... need to implement stand_alone_tag_list.. it would be really clever to be able to figure out that list from a dtd..

File bezutils.cc: should probably look into lib2geom

File boxarrange.cc: *** break this down further to: boxes.h, rowcolarrange.cc/h, tablearrange.cc/h???
*** implement all the LRTB, ...

Member Laxkit::mapname (char *buf, int m): be ablte use control, meta, and alt?

Member LaxFiles::check_dirs (const char *dirs, char make_too): *** on failure, should remove newly created directories... when doing that, should check that those new dirs are still empty?
*** always follows links, maybe should have some sanity check for that..

Member LaxFiles::is_good_filename (const char *filename): this could be broken down into is_good_path() and is_good_basename();

Member LaxFiles::make_filename_base (const char *f): have something like "blah##-##.ext" -> "blah%02d-%02d.ext" and maybe "blah##\###" -> "blah%02d%03d"? pass in option to say how many fields there should be, and how many there ended up being

Member LaxFiles::readable_file (const char *filename, FILE **ff): does not currently check sanity of file when opening.
add a return error string

Member LaxFiles::get_bookmarks (const char *file, const char *filetype): need to lock files on opening

Member LaxFiles::recently_used (const char *mimetype, const char *group, int includewhat): not a whole lot of error checking in here yet.

Member LaxFiles::touch_recently_used (const char *file, const char *mime, const char *group, const char *timestamp): there could be more error checking in here. If recent file spec changes, could well break this.

Member Laxkit::id_from_str (const char *str, char createifabsent): *** make threadsafe

Member Laxkit::lark_position (const char *str, int *c): make this faster via binary search

Member Laxkit::str_from_id (int id): *** these ultimately will replace X Atoms for the basic message types. Using X Atoms leaves lots of silly residue in the X server after programs end.
*** make threadsafe

Member Laxkit::_laximlib_generate_preview (const char *original, const char *preview, const char *format, int width, int height, int fit): *** afterwards, make sure preview was actually written

Group math: *** must add in and make available the bez/bezpatch matrix utils from bezinterface.cc and patchinterface.cc

Member LaxInterfaces::bez_bbox (flatpoint p, flatpoint c, flatpoint d, flatpoint q, DoubleBBox *bbox, double *extrema): *** something is fishy with quad, occasionally finds way out extreme??

Member LaxInterfaces::bez_near_point (flatpoint p, flatpoint *points, int n, int maxpoints, double *t_ret, int *i_ret): I'm sure this could be optimized and improved somehow.

Member LaxInterfaces::bez_point (double t, flatpoint p1, flatpoint c1, flatpoint c2, flatpoint p2): *** make sure this is really optimized!

Member LaxInterfaces::bez_points (flatpoint *to_points, flatpoint *from_points, int resolution, int ignorefirst): optimize me

Member LaxInterfaces::getPolyT (double *N, double n, double t0): this could be optimized a little

Member LaxFiles::one_of_them (const char *str, const char **list): move this to strmanip.h?

Group attributefileformat

****** the IntAttribute types of functions use functions like strtol, which will stop parsing at first character that is invalid for the conversion, but for a value to be truly converted, "34" is ok but "34g" is not a pure integer, for instance. there is no default check for things like that. It should be an option.

dump_in_from_buffer(const char *buf) and dump_out_to_buffer(char *buf) ?

Group attributefileformat: ***need some way to automatically set how many spaces a tab is equal to. it is currently 1, which is irritating when your editor automatically puts in a tab rather than spaces..

Group laximages: In the future, will probably want some kind of load_image_to_buffer, but that means I have to understand color management much more thoroughly.

Member Laxkit::png_to_ximage (Display *dpy, Visual *vis, char *filename, XImage **alpha): return an error instead??

Group laxutils: *** It might be clever to have a basic hot-swappable graphics backend for the whole of Laxkit. This backend would be responsible for providing functions to make marks onto drawables, namely: text (horizontal and angled), line segments, polylines (open or filled), ellipses (open or filled), bevels, changing fg/bg color, linewidth, and function. Also image loading for icons/images and cursors!! This could be achieved fairly easily by making the functions in laxutils.cc be function pointers that can be changed by an application. Notable backends would be plain Xlib, Imlib2, cairo, antigrain, and libart.

Group laxutils: ***migrate xpmfiletocursor to app->MakeCursor??
write a xpm reader to not have libXpm dependency?

Member Laxkit::coloravg (XRenderColor *result, XRenderColor *a, XRenderColor *b, float r): *** this surely has clamping errors

Member Laxkit::get_placement (LaxImage *image, const char *label, int gap, unsigned int how, int *w, int *h, int *tx, int *ty, int *ix, int *iy): implement all of: LAX_ICON_ONLY (0) LAX_TEXT_ONLY (1) LAX_TEXT_ICON (2) LAX_ICON_TEXT (3) LAX_ICON_OVER_TEXT (4) LAX_TEXT_OVER_ICON (5) LAX_ICON_STYLE_MASK (7)

Member Laxkit::getextent (const char *str, int len, int *ex, int *ey, int *fasc, int *fdes, char r): r doesn't work any more. returns height, but not sure how to get actual visual ascent and descent!
this is a little messy with mixup between advance and extent.

Member Laxkit::getextent_latin1 (const char *str, int *ex, int *ey, int *fasc, int *fdes, char r): REMOVE(?)

Member Laxkit::printxpm (const char *filename): *** does no sanity checking on file names

Member Laxkit::textout (Drawable drawable, const char *thetext, int len, int x, int y, unsigned long align): does Xft handle right to left rendering?
this is in serious hack stage. need some way to reasonably define the font and color to use

Member Laxkit::textout_latin1 (Drawable drawable, const char *thetext, int len, int x, int y, unsigned long align): remove this? DEPRECATED!!

Member Laxkit::xpmfiletocursor (anXWindow *win, const char *filename): *** does no sanity checking on file names

Member Laxkit::xpmfiletopixmaps (const char *filename, Drawable d, Pixmap *clipmask, int *width, int *height): *** does no sanity checking on file names

Member Laxkit::xpmfiletoximages (const char *filename, int depth, XImage **clipmask): *** does no sanity checking on file names

Group Strman

***convert to using memcpy and memmove instead of stuff like s[c]=s[c+1]

*** some functions that have a dest and a src must be careful not to delete[] dest if src==dest, must go through and check for that

make a strprintf(&str,"format",args), would have to step through format, and figure out how big a string is needed, then allocate it for str.

perhaps wrap this in LaxStr namespace?

Member appendnstr: *** question: is *&dest allowed to be NULL?

Member increment_file: should have "blah001.jpg"->"blah002.jpg", and perhaps optionally allow "blah.tar.gz" -> "blah2.tar.gz"

Member lax_basename: maybe should move lax_basename(), lax_dirname(), and increment_file() to fileutils? they only in strmanip because they don't really need the filesystem to operate.

Member replaceall: **** this needs work and testing

Member split: investigate strtok strsep, make a split version that puts '\0' on delimiters, does not allocate new strings, returns new'd array of char* that point to start of each field..

Member Laxkit::transform_from_basics (double *result, double x, double y, double sx, double sy, double angle, double shear): *** finish me!

Member Laxkit::transform_to_basics (double *m, double *x, double *y, double *sx, double *sy, double *angle, double *shear): *** finish me!

Group vectors: Should perhaps not have typedef spacevector point? have spacepoint/spacevector?

Group interfaces: *** BezInterface has many useful features that I haven't ported over to BezPathOperator yet. The others (including BezInterface) are a bit old, and somewhat broken with how interfaces are used currently. Same goes for LinesInterface

Group interfaces: *** there should be interfaces for all postscript language level 3 gradient types. linear, radial, and tensor/coons gradients are in progress, need to do the triangle strip and triangle lattice gradients.. maybe not the type 1 generic function gradients..

Group interfaces: The bez patches are currently more like a bezier patch lattice, rather than how Postscript LL3 does it, which is a freeform bezier patch setup. Postscript has triangle lattices, but not bez patch lattices!! What a foolish oversight!! should be able to do the standard ps way in addition to the lattice way.

Group interfaces: *** edit interface docs, do a better how to

Member LaxInterfaces::PathsData::dump_out (FILE *f, int indent, int what): Make this access the basepathops in PathInterface to dump out the right owner info... right now, not calling any dump_out in Path or in Coordinate..

Member LaxInterfaces::ImagePatchData::dump_out (FILE *f, int indent, int what): *** assumes data is from filename. It shouldn't.

Member LaxInterfaces::ColorPatchData::dump_out (FILE *f, int indent, int what): *** should allow floating point representation of colors in range [0.0, 0.1] and specification that colors are 8bit, or other bit depth, like have field "colordepth 16|8|float"

Page The Laxkit API: this may change. The anXWindow class may be reference counted at some point.

Page Math Primer: ***todo: a page for affine/rotate/shear/3x3 persp transforms

Page Math Primer: *** explain where the hell that patch equation came from)

Page Xlib Primer for Laxkit: this page needs updating!!

Page The Laxrc File: directories and fonts are still basically unimplemented..
many windows still need to pay attention to some of these settings, like pad and bevel

Tue Nov 6 08:46:47 2007, Laxkit

General To Dos

Specific To Dos

Interfaces Todo

anXApp todos