Scott as usual had an insight too "about the browse"r

and Gil might be mstaken for a communist ....

am sure a lot of folks believed Marc ................

now this is what we call a browser war .....note the losers

Instantly capture ideas, meeting notes and concepts using sketches, handwritten notes or type
Drag and drop branches to quickly structure that information
Visually identify important tasks, issues and relationships
Refine information based on group feedback
Facilitate a clear understanding of the topic at hand
Organize tasks, supporting documents, existing resources and materials in a single application

Immediately export to popular formats, including:
Microsoft Word
Microsoft PowerPoint
Microsoft Outlook
Microsoft Project
HTML Web site
MPX(via add-in), RTF, or image formats
Using SmartMapX Technology, customized solutions can be crafted to allow information sharing with any third party application

is a bird , its a plane its mindmanager

MindManager for Tablet PC Named Codie Award Finalist

there you go Loren

"Your project registration for SourceForge.net has been approved. "
We now have a new home at Sourceforge. Will set up the workspace as soon as i can

Project Descriptive Name: WriteFree

and yes there are bigger displays

and for pure style

its life............

, it might also be possible to provide layered ink

wonder how important recognition is for note taking, wonder how i can measure that

selection with a criteria

... Tablet PC Developer moved to GotDotNet.

Overall Tablet PC 2004 brings slate and convertible users who focus on handwriting some needed improvements in the recognition. However the compromise on removing Write Anywhere and the lack of editing buttons will cause some additional grief for users that want a seamless Tablet PC experience. Further if you plan on using your Tablet PC for ink alone, there are no improvements in Tablet PC 2004.

Tablet PC Talk - First Look at Tablet PC 2004 Alpha

yes this make s sense
Tablet PC Talk - First Look at Tablet PC 2004 Alpha: "Summary
Overall Tablet PC 2004 brings slate and convertible users who focus on handwriting some needed improvements in the recognition. However the compromise on removing Write Anywhere and the lack of editing buttons will cause some additional grief for users that want a seamless Tablet PC experience. Further if you plan on using your Tablet PC for ink alone, there are no improvements in Tablet PC 2004."

on my way ...

seems like i can't find a good copy of the WriteFree [old design], was hoping to release that with the menu code fixed. The binaries and sources that we posted up on gotdotnet should be good enough for anyone that may want to fix it. I hope to get some dev time as i make my way back to the forest....

the new writefree does not use a simplified document.

am doing selection, will get the new design and software out as soon as i can, lots of typing involved :)

i don't see any value in using an ink picture for WriteFree, guess i hadn't given it enough though, but am getting rid of that design, i am going with a different better design to be relased shortly, i just think an ink picture is pretty limited and a bit heavy weight...
there is no value for in limiting WriteFree to ink

"The InkPicture control provides the ability to place an image in an application and enable users to add ink on top of it. It is intended for scenarios in which ink is not recognized as text but is instead stored as ink."



we want to make it more flexible , for example there is no reason why a WF note shouldn't have as many inkpics as you want, you get where am going so a WF note is about to change

ok because of the single fact that you have to log in to gotdotnet to get to the workspace, we are moving this project to sourceforge, does anyone have any ideas , i do like the interface and VS.Net 2003 integration

Project Registration: Submission completed
Progress: 100% completed
NOTE: You should not reload this page. Reloading this page in your browser may result in odd errors, duplicate Tracker postings (if applicable) and generate duplicate copies of the notification email which is sent to the email address we have on-file. Please do not reload this page.

Status of your request: Registration completed successfully.

Your request should be reviewed by SourceForge.net staff in the next two business days (9AM to 5PM, Monday through Friday). Response regarding your project (notice of rejection/approval) will be sent to you via email (to the email address we have on-file for your account).

For your convenience, a copy of the details you submitted about your project has also been sent to you via email. Please keep this information in a safe place, for future reference.

Should you have questions or concerns regarding the status of your project registration, please submit a Support Request.

You may check on the status of your project at any time using the My SF.net Projects page. Until your registration is reviewed by SourceForge.net staff, it will be shown in the list of Pending Projects on the My SF.net Projects page. After review has occurred, it will appear in the list of Active or Rejected projects, depending on the outcome of that review.

Registration completed successfully.
t
we are getting a new home .... we should know before christmas, i really do like lots of the stuff at gotdotnet, but sourceforge gives you terminal console access to their linux boxes,hmmmm, i chose the BSD license since that's my favourite open source licence

ok i slept, am up now and yes next week is a 2 day week,

a writefree note on a conceptual level is a background picture and ink, now thats bound to change soon, but currently its implemented as the ink you render on WriteFree and your template,which is an Image file set to the Image property of InkPicture. I am adding all the editing features and so on. That inkpic and its ink, actually your ink is the document.

back to writefree "developed on a desktop, on a big high res laptop , a writefree notes document is an InkPicture , inkpicture from google

reading some boards i saw a question on developing on tpc, this has been around be fore and it didn't seem like there were too many ideas or opinions, well been running VS .NET 2002 and 2003 on portege 3500 with a gig of ram and a tc1000-256M since june , works fine .......the only thing you will not appreciate is that low res 10-12 inch display, consequently for VS.NET(keyboard biased) its not a practical development environment, see Loren's blog on some very interesting ideas on developing with a pen

fixed some bugs , but since no one seems to be clamouring for a release i will rework the document class, and maybe rethink it a bit more, the design is very simple, a notes document is an inkPicture

finally home,

undo-redo done, no time to upload, will have to do that later today, later , its travel day :(

now this is the direction that computing in general will go, real human friendly interfaces

am not sure why blogger doesn't treat us like real customers, oh well, hope it has nothing to do with google, i like google, and i like radio

gotdotnet is flaky

yep i got

GotDotNet Workspaces
Your request cannot be processed at this time.
The application may be under heavy load or may be encountering an internal error.
The following documents may help you in troubleshooting this problem:
Readme and current known issues
Frequently asked questions
Please use the Feedback Form to report your error, including the URL you were trying to access and we will investigate the problem further.
We apologize for any inconvenience this may have caused you.
Return to the Workspaces Announcements page



if i get time, am done with blogger and gotdotnet, geues where are going, though i don't love CVS, but i love terminal console access, and guess who is running a serious blog hosting service

another day done, ok, never got to work on our project, and though i got lots of the editing stuff done (we are getting a larger standard toolbar -- remember we had 2, 1 just grew ) ummm and we will revamp the gotdotnet site and look at sourceforge too. Its 9:00 EST, i have almost 2 hours to work on WF so i hope we can get some stuff out

will get the good R1 up there shortly

at least, its supposed to be a Notes taking and Management system. Taking notes may note be very revolutionary, but managing notes might be the killer app of the tablet pc. And as previously posted ink is implemented very well so saving it in many different ways is not too bad ....
any ways its a note taking and management system

a very complete feature set , auto saving, note books , now all we need is more battery time, and larger displays with higher resolutions .....lonestar , longhorns and vector graphics

i fell asleep at about 2:00 last night so i wasn't able to post WriteFree, am at my day job so i might not get a chance to do the same , however if i get a chance during my lucnh break or something i will do the same.
I think OneNote is going to be the future of Office

for folks who have been keeping track of my wifi ranting, this week i have acess to 5 networks, one community netwrok and the rest private, folks should do better with their security,3 of these nets let you browse shares after you connect, one guy is sharing his "My Documents", this guy is the CEO

now back to undo/redo

where does ink come from?

where doth that ink come from is the important question. Where are we going to get that ink from. Remember InkOverLay and the baby InkCollector who can only collect (thats why they named them InkCollector). Thats where all the ink comes from..
all ink in the world, all ink ever comes from the overlay and the collector, the collector like tax collectors has less capability...
Ink Collection (and not on your desk blotter, on the Microsoft Windows Tablet PC Edition). Ink collection begins with the digitizer. A user places a pen on the digitizer and starts to write. the collection of ink data "flows" from the pen. You then use the InkCollector object to get the data that comes from the digitizer.
InkCollector Object
The InkCollector object captures ink input from available Tablet devices. The InkCollector object only collects ink and gestures that are input into a specific window. A very efficient event sink renders this input in real time. The InkCollector object captures the input and directs it into an Ink object.
-if you use two pens the ink may or may not flow those that really depends on the implementation of the entire input system, down to the driver level

Ink Collector mechanics
The InkCollector object attaches itself to a known application window. It then enables users to employ any available Tablet PC device (including the mouse) to lay down ink in real time on that window. The ink strokes that it collects are stored in an associated Ink object. These strokes can then be manipulated or sent to a recognizer for recognition. The InkCollector object also notifies the application when a cursor comes into range of any of the Tablet PC devices that are being used.There are of course more details but on a very high level thats what happens.

InkOverlay Object (The Mother of Ink creating objects.) aka "the overlay"
The InkCollector object, discussed above, is useful for applications to provide their own model for selecting, erasing, and other user interaction. The InkOverlay object is a superset of the InkCollector object that provides editing support. This is useful for applications to integrate ink drawing and editing into their own document canvas by using a set of standard ink selection models that the object provides.

Both the InkCollector object and the InkOverlay object (as well as the InkPicture control) use common constructs, such as the Ink object and the InkDrawingAttributes collection, so that the basic way to interact with ink is the same for all Objects.

InkOverlay is a COM object that is useful for annotation scenarios in which users are not concerned with performing recognition on ink but, instead, are interested in the size, shape, color, and position of the ink. It is well suited for taking notes and basic scribbling. The default user interface is a transparent rectangle with opaque ink. InkOverlay extends the InkCollector class in three ways:

• It raises events for begin-stroke, end-stroke, and ink attribute changes.
  
• It enables users to select, erase, and resize ink.
  
• It supports Cut, Copy, and Paste commands.
  

InkOverlay tactical mechanics:
3 basic steps are required to get an InkOverlay doing its thing - commonly called the CAT procedure for create, attache, true-it(set its Enabled property to true) . this is the same for InkCollector
CAT procedure

• Instantiate an InkOverlay object.
  
• Attach the hWnd property of an InkOverlay object to that of another window.
  
• Set the InkOverlay Enabled property to True.
  

The InkOverlay object includes basic printing support, but you must implement print preview or other advanced printing capabilities. InkOverlay persists ink in Ink Serialized Format (ISF) format.
...other interesting things about InkOverlay are the EditingMode property that determines what the pen does when it gets to the digitizer, the events (such as InkAdded, InkDeleted, and Stroke)
Hard to talk about this super inkers without talkingabout the
Drawing Attributes object
A DrawingAttributes object describes how any known set of ink is to be drawn. A DrawingAttributes object includes basic properties such as Color, Width, and PenTip. It can also encompass advanced parameters, such as variable transparency and Bezier smoothing, that can provide interesting effects or improve ink readability.

a little more ink from:
PenInputPanel Object
The PenInputPanel object allows you to easily add in-place pen input to your applications. The PenInputPanel is available as an attachable object that allows you to add Tablet PC Input Panel functionality to existing controls. The user interface is largely mandated by the current input language. You have the option of choosing the default input method for the pen input panel, either handwriting or keyboard. The end user can switch between input methods using buttons on the user interface.

and thus we now have the INK.....all the ink you see , any ink you can make and every ink there ever will be in in SDK 1.0 and 1.5 will have entered its existence from the above ways. The most versatile you might realize is the Overlay.

*note that Overlay is one word so the class name is Overlay not OverLay,

maybe i have been looking at this stuff for too long but it sounds like something that happens at a truck stop or something bad and unexpected like waylay, maybe thats what this thing is doing to linux
whats an overlay anyway
from dictionary.com
8 entries found for overlay
o ver lay1 ( P ) Pronunciation Key (vr-l)
tr.v. o ver laid, (-ld) o ver lay ing, o ver lays
To lay or spread over or on.

To cover the surface of with a decorative layer or design: overlay wood with silver.
To embellish superficially: a simple tune that was overlaid with ornate harmonies.
Printing. To put an overlay on.
To create (a new area code) having the same boundaries as another: In Maryland, area code 240 was overlaid on top of area code

am not sure , the API designer needs to tell us why the fuck he called it Overlay, i guess it covers a window?

once more
an Ink object is a container
an Ink object is a container for stroke objects
an Ink object has a strokes collection that references its strokes objects

of course its a container , but more important its single meaning in life is to contain stroke objects.

And yes a Strokes collection is only existent in the context of an Ink Object.

A Strokes collection is created by an Ink object and can refer only to Stroke objects owned by that same Ink object.

simply to think of it in OO terms, encapsulation and all that ...

an Ink object is a container for Stroke objects, and a Strokes collection references Stroke objects.

ok we are going to overdo it a bit
an Ink object is a container for Stroke objects, and a Strokes collection references Stroke objects.
an Ink object is a container for Stroke objects, and a Strokes collection references Stroke objects.
an Ink object is a container for Stroke objects, and a Strokes collection references Stroke objects.
an Ink object is a container for Stroke objects, and a Strokes collection references Stroke objects. an Ink object is a container
an Ink object is a container for Stroke objects,
an Ink object has a Strokes collection that references the Stroke objects.

an Ink Object has a collection of stroke objects that are stored in the Strokes Collection -- that's it....

INK is simply a bunch of strokes...How elegant.....

public class Ink : ICloneable

that's what that's about...Who is complaining.

A list of all the properties of the Ink Class reads like below, notice that the rest of the stuff is basically clueless, meaningless and really not such a big deal and could have been implement at the stroke level or wherever.

Property Description
CustomStrokes Returns the collection of custom strokes to be persisted with the ink.
Dirty Returns or sets the value that specifies whether the strokes of an Ink object have been modified since the last time the ink was saved.
ExtendedProperties Returns the collection of application-defined data that is stored in the Ink object.
InkSerializedFormat Returns a string that contains the name that should be used to query DataObject on the Clipboard to see if it contains that particular format
and what its all about

Strokes Returns the collection of all of the strokes in the Ink object.

more detail later with some code and that promised journal clone

"Strokes Collection"
Contains the collection of Stroke objects that represent a single ink stroke.

Strokes collections are references to ink data and are not the actual data itself.


Caution In managed code, to avoid a memory leak you must explicitly call the Dispose() method on any Strokes collection to which an event handler has been attached before the collection goes out of scope. "
from Microsoft Tablet PC SDK definition for Strokes Collecction

this abstraction represents a single ink stroke, it implements ICollection and IEnumerable , has 28 methods and 2 events(StrokesAdded and StrokesRemoved ) and 7 properties that take care of things like how many Stroke objects are stored in the collection. In addition to the standard collection methods that take care of adding ,removing, moving stroke objects there are methods to scale and rotate stroke objects (remember that from PacketProperties that stroke objects are really just a fancy polyline - you have all the information that is required to do all kinds of vector type transformations on strokes) It would have been easy for the designers of the API to keep it at the bitmap level but the it might not have been the same magical ink that we have today. Requires more data to be stored but gives real powerful ink.


PacketProperties of course are very exciting to think about but thats too much paper for folks that just recently (70 centruries ago) figured out how to abstract on a surface. So we will still talk abit about Strokes. That power is coming shortly.

A Stroke Object is contained by an instance of an Ink Object. Ink Objects define the scope of a Stroke Object. an Ink Object owns zero or more Stroke objects. Yes am going to capitalize all the class names i reference. Thats because the SDK did such a good job at OO that its literally possible to talk about this and it would sound like a normal english conversation, talk about Object abstraction.

liteally the ink is made up of strokes and the strokes are made up of packets described by PacketProperties.

its hard to talk about ink persistence without talking about ink itself. We have all heard how ink is a first class citizen in the the Tablet PC SDK object model.
Another way of looking at it is that the Ink class is the outermost entry point into the Ink Data API, and it is analogous to a document class , much like text or files are the basis of keyboard based computing.

User input occuring on InkCollector and InkOverlay create Stroke objects.
Stroke objects are the characters or basic building blocks of an ink document . Each Stroke objects represents a stroke of digital ink, the same way each handritten stroke represents some type of human intention, a doodle and scribble, a straight line, a letter, a number, a stroke of the pen. Each time you actually take a pen to paper , you are really create strokes of some type. Thats what is abstracted by Stroke objects. A stroke.
-Movement of the pen on a surface is essentially what is captured though more information is collected than the movement - its scary to imagine how powerful this strokes are compared to ordinary pen and paper strokes.
paper and pen interaction of course has a lot of expressiveness but once you have a computer underneath , you can the capability to store things like the time the stroke was done, a serial number for each stroke, even the angle the pen was making with the digitizer....thats why paper is at the end of its time, and of course there 's the whole "save a tree thing"

Stroke objects are are a collection of packets and each packet contains an x,y location and other packet properties. Next is the almighty PacketProperty Object.
Your stroke is represented as a collection of PacketProperties

Is JNT really a proprietary binary format?
Ok , couple of things first. Ink is ink and i would rather it stayed ink. That probably means i would rather have the actual serialized object . Thats where ISF shows up.

Ink Serialized Format (ISF) , the most compact persistent representation of ink is extensible with custom attributes (identified by a GUID) and allows you to store any kind of data or metadata as an attribute in an ISF stream.

Alright , and .....ISF is a format specific to Windows XP Tablet PC Edition, and the only way you can get at ISF is to use the Ink object's Load and Save methods.....

everything else starts after ISF.
For best performance and total control of ink ISF is the way to go with whatever enhancements you need to work with ink

For heterogeneous content, use fortified GIFs to encode ink into HTML documents. Browsers and html's hyper linking are your friend in that situation

For Images you could move bitmap and metafile that are got from inks conversion to GIF

And we can alsoe encode ink in the RTF as OLE objects. This is very useful for pasting into an OLE container, such as Microsoft Word.

and of course the most useful format is XML .

the are 4 supported PersistenceFormat, though it essentially is 2 formats , you can go anywhere from this. Actually go any where and come back ...

enum PersistenceFormat {
InkSerializedFormat = 0,
Base64InkSerializedFormat = 1,
Gif = 2,
Base64Gif = 3
};

i used to post ink related stuff to my other blog while working on WriteFree stuff, most of the posts are basic stuff about ink and related technologies.....i'll copy it over here some time

ok, was supposed to work on WriteFree until 10:00 EST but am still working on it....Will post the stuff wherever, am implementing undo/redo right now,

ok, maybe we need comments here ;P

oh well, i don't mind ... The RSS Bandit project has moved to SourceForge. The new URL for the project is http://sourceforge.net/projects/rssbandit

hmmmm,

R1 screw up, the code i uploaded was broken, while cleaning it up on a low res display i deleted a bunch of menuing code, so the menus in the uploaded R1 were broken, code is simple , worth fixing, will upload the working version this evening.....now the good news is design work for R2 moved well and we now have an editor ... and libs...more about that very shortly....there never seems to be too much activity in the gotdotnet boards

this is totally cool

and thats what the logo looks like

another

Yes we have a screenshot too

Write Free , Open Source Journal: News item: "R1 beats Windows Journal because R1 runs on Windows 2000, XP and TPC XP edition. "

technically WriteFree Journal is an InkPicture, 2 toolbars, menus and image files for the template. All development was done on XP or W2K, sometimes with a tablet. The image files are Windows Journal templates exported to tiff and then converted to jpg (am not sure why i went to the trouble).
Most of the development was done using the designers in VS.NET.
R1 will be refactored and then will be refactored some more, it will be componetized so that we can reuse alot of the common stuff.
There will be an R2 and apart from thinking it may be more like OneNote than Windows Journal i don't know what its going to be like.
One of my fears about ink and winforms is that sometimes when you do particular things (zoom in and out for example) it stops behaving like ink and paper, it starts behaving like a windows computer (hanging and might bluescreen) .... that has to change. Paper never hangs and does not need saving (thats why auto save might make sense - in its own thread)

Other than that , i just need to get a break from work to test the thing and see what else i need to do to make it a useful program :)

one thing about WriteFree Journal R1 is that like Windows Journal it seems to suffer performance issues of one type or another, like saving seems to take quite a bit of time. I never multi threaded it and i should. There is also the issue of auto-save, i will bring that up on the messageboard to see what everyone thinks.
Sucks that i can't say much about it since i haven't actually used it. I did some smoke testing but thats about all the testing that i did.

A neat feature of WriteFree Journal R1 is the ability to read and take notes at the same time. A menuitem provides 11 different transparency levels including totally invisible (quite useless) and 2 toolbar buttons provide 9 transparency levels each. I haven't had time to actually beta test R1, so am curious as to how folks will use this feature.
The editor is not as lightwieight as i woul d like it to be and there should be more work done in that area after i get beta testing feedback.
We went with a single document model since not only was that easier to do but most of us never do lots of multiple document notes.

R1 is finally ready

lots of refactoring needs to be done.