workbench/classes/zune/nlist/demo/NListtree-Demo.c

   1 /***************************************************************************
   2
   3  NListtree.mcc - New Listtree MUI Custom Class
   4  Copyright (C) 1999-2001 by Carsten Scholling
   5  Copyright (C) 2001-2014 NList Open Source Team
   6
   7  This library is free software; you can redistribute it and/or
   8  modify it under the terms of the GNU Lesser General Public
   9  License as published by the Free Software Foundation; either
  10  version 2.1 of the License, or (at your option) any later version.
  11
  12  This library is distributed in the hope that it will be useful,
  13  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  Lesser General Public License for more details.
  16
  17  NList classes Support Site:  http://www.sf.net/projects/nlist-classes
  18
  19  $Id$
  20
  21 ***************************************************************************/
  22
  23 #if defined(__AROS__)
  24 #define MUI_OBSOLETE 1
  25 #endif
  26
  27 /*
  28 **      Includes
  29 */
  30 #include <proto/muimaster.h>
  31 #include <proto/exec.h>
  32 #include <proto/intuition.h>
  33 #include <proto/utility.h>
  34
  35 #if !defined(__amigaos4__)
  36 #include <clib/alib_protos.h>
  37 #endif
  38
  39 #include <exec/memory.h>
  40 #include <exec/types.h>
  41
  42 #include <mui/NListtree_mcc.h>
  43 #include <mui/NListview_mcc.h>
  44 #include <mui/NList_mcc.h>
  45
  46 #include <string.h>
  47 #include <stdio.h>
  48 #include <time.h>
  49
  50 #ifdef MYDEBUG
  51  #define bug kprintf
  52  #define D(x)
  53  void kprintf( UBYTE *fmt, ... );
  54 #else
  55  #define bug
  56  #define D(x)
  57 #endif
  58
  59
  60 #ifndef MAKE_ID
  61 #define MAKE_ID(a,b,c,d) ((ULONG) (a)<<24 | (ULONG) (b)<<16 | (ULONG) (c)<<8 | (ULONG) (d))
  62 #endif
  63
  64 #include "SDI_hook.h"
  65
  66 #ifndef MUIA_Slider_Level
  67 #define MUIA_Slider_Level                   0x8042ae3a /* V4  isg LONG              */
  68 #endif
  69
  70 /*
  71 **      Do not use stack sizes below 8KB!!
  72 */
  73 LONG __stack = 16384;
  74
  75
  76 /*
  77 **      MUI library base.
  78 */
  79 struct Library *MUIMasterBase = NULL;
  80
  81 #if defined(__amigaos4__)
  82 struct Library *IntuitionBase = NULL;
  83 #else
  84 struct IntuitionBase *IntuitionBase = NULL;
  85 #endif
  86
  87 #if defined(__amigaos4__)
  88 struct IntuitionIFace *IIntuition = NULL;
  89 struct MUIMasterIFace *IMUIMaster = NULL;
  90 #endif
  91
  92 struct MUI_NListtree_TreeNode *tntest;
  93
  94 /*
  95 **      MUI objects.
  96 */
  97 STATIC APTR             app, window,lt_nodes,
  98                                 tx_info1,       tx_info2,       tx_info3,
  99                                 sl_treecol,     st_string,
 100                                 bt_open,        bt_close,       bt_expand,      bt_collapse,
 101                                 bt_insert,      bt_remove,      bt_exchange,bt_rename,
 102                                 bt_move,        bt_copy,        bt_moveks,      bt_copyks,
 103                                 bt_find,        bt_parent,      bt_sort,        bt_getnr,
 104                                 bt_redraw,      bt_selected,bt_showtree,bt_seltogg,
 105                                 bt_test,        bt_test2,       bt_test3,       bt_test4;
 106
 107
 108 /*
 109 **      Sample tree structure.
 110 */
 111 struct SampleArray
 112 {
 113         const char *name;
 114         ULONG flags;
 115 };
 116
 117 STATIC const struct SampleArray sa[] =
 118 {
 119         { "comp", TNF_LIST | TNF_OPEN },
 120         {        "sys", TNF_LIST | TNF_OPEN },
 121         {                "amiga", TNF_LIST | TNF_OPEN },
 122         {                        "misc", 0x8000 },
 123         {                "mac", TNF_LIST },
 124         {                        "system", 0x8000 },
 125
 126         {"de", TNF_LIST | TNF_OPEN },
 127         {        "comm", TNF_LIST },
 128         {                "software", TNF_LIST },
 129         {                        "ums", 0x8000 },
 130         {        "comp", TNF_LIST | TNF_OPEN },
 131         {                "sys", TNF_LIST | TNF_OPEN },
 132         {                        "amiga", TNF_LIST },
 133         {                                "misc", 0x8000 },
 134         {                                "tech", 0x8000 },
 135         {                        "amiga", 0x8000 },
 136
 137         {"sort test", TNF_LIST | TNF_OPEN },
 138         {        "a", 0 },
 139         {        "x", TNF_LIST },
 140         {        "v", 0 },
 141         {        "g", TNF_LIST },
 142         {        "h", 0 },
 143         {        "k", TNF_LIST },
 144         {        "u", 0 },
 145         {        "i", TNF_LIST },
 146         {        "t", 0 },
 147         {        "e", TNF_LIST },
 148         {        "q", 0 },
 149         {        "s", TNF_LIST },
 150         {        "c", 0 },
 151         {        "f", TNF_LIST },
 152         {        "p", 0 },
 153         {        "l", TNF_LIST },
 154         {        "z", 0 },
 155         {        "w", TNF_LIST },
 156         {        "b", 0 },
 157         {        "o", TNF_LIST },
 158         {        "d", 0 },
 159         {        "m", TNF_LIST },
 160         {        "r", 0 },
 161         {        "y", TNF_LIST },
 162         {        "n", 0 },
 163         {        "j", TNF_LIST },
 164
 165
 166         {"m", TNF_LIST },
 167         {        "i", TNF_LIST },
 168         {                "c", TNF_LIST },
 169         {                        "h", TNF_LIST },
 170         {                                "e", TNF_LIST },
 171         {                                        "l", TNF_LIST },
 172         {                                                "a", TNF_LIST },
 173         {                                                        "n", TNF_LIST },
 174         {                                                                "g", TNF_LIST },
 175         {                                                                        "e", TNF_LIST },
 176         {                                                                                "l", TNF_LIST },
 177         {                                                                                        "o", 0 },
 178
 179         {"end", TNF_LIST },
 180         {        "of", TNF_LIST },
 181         {                "tree", 0 },
 182
 183         { "Sort Test 2", TNF_LIST },
 184
 185         { NULL, 0 }
 186 };
 187
 188 /*
 189 **      This function draws the sample tree structure.
 190 */
 191 STATIC VOID DrawSampleTree( Object *ltobj )
 192 {
 193         struct MUI_NListtree_TreeNode *tn1, *tn2, *tn3;
 194         char txt[128];
 195         WORD i = 0, j;
 196
 197         tn1 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, MUIV_NListtree_Insert_ListNode_Root, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 198         tn2 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, tn1, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 199         tn1 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, tn2, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 200         tn1 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, tn1, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 201         tn1 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, tn2, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 202         tntest = tn1 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, tn1, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 203
 204         tn1 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, MUIV_NListtree_Insert_ListNode_Root, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 205         tn2 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, tn1, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 206         tn2 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, tn2, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 207         tn2 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, tn2, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 208         tn3 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, tn1, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 209         tn1 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, tn3, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 210         tn2 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, tn1, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 211         tn3 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, tn2, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 212         tn3 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, tn2, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 213         tn3 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, tn1, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 214
 215         tn1 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, MUIV_NListtree_Insert_ListNode_Root, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 216
 217         for( j = 0; j < 26; j++ )
 218         {
 219                 DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, tn1, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 220         }
 221
 222         tn1 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, MUIV_NListtree_Insert_ListNode_Root, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 223
 224         for( j = 0; j < 11; j++ )
 225         {
 226                 tn1 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, tn1, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 227         }
 228
 229         tn1 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, MUIV_NListtree_Insert_ListNode_Root, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 230         tn1 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, tn1, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 231         tn1 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, tn1, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 232
 233
 234         tn1 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, sa[i].name, (IPTR)sa[i].flags, MUIV_NListtree_Insert_ListNode_Root, MUIV_NListtree_Insert_PrevNode_Tail, sa[i].flags ); i++;
 235
 236         for( i = 0; i < 2500; i++ )
 237         {
 238                 if ( i % 2 )    snprintf( txt, sizeof(txt), "Sort Entry %d", i + 1 );
 239                 else                    snprintf( txt, sizeof(txt), "Entry Sort %d", i + 1 );
 240
 241                 tn2 = (struct MUI_NListtree_TreeNode *)DoMethod( ltobj, MUIM_NListtree_Insert, txt, 0, ( i % 5 ) ? tn2 : tn1, MUIV_NListtree_Insert_PrevNode_Tail, ( i % 5 ) ? TNF_LIST : 0 );
 242         }
 243
 244
 245         DoMethod( ltobj, MUIM_NListtree_InsertStruct, "This/is/a/very/long/test/for/Blafasel_InsertStruct", 0, "/", 0 );
 246         DoMethod( ltobj, MUIM_NListtree_InsertStruct, "This/is/another/very/long/test/for/Blafasel_InsertStruct", 0, "/", 0 );
 247 }
 248
 249
 250
 251 static struct MUI_NListtree_TreeNode *GetParent( Object *obj, struct MUI_NListtree_TreeNode *tn )
 252 {
 253         if ( tn != NULL )
 254         {
 255                 return( (struct MUI_NListtree_TreeNode *)DoMethod( obj, MUIM_NListtree_GetEntry, MUIV_NListtree_GetEntry_ListNode_Root, MUIV_NListtree_GetEntry_Position_Parent, 0 ) );
 256         }
 257
 258         return( NULL );
 259 }
 260
 261
 262 static struct MUI_NListtree_TreeNode *GetParentNotRoot( Object *obj, struct MUI_NListtree_TreeNode *tn )
 263 {
 264         if((tn = GetParent( obj, tn)))
 265         {
 266                 if ( GetParent( obj, tn ) )
 267                 {
 268                         return( tn );
 269                 }
 270         }
 271
 272         return( NULL );
 273 }
 274
 275
 276 struct MUI_NListtree_TreeNode *IsXChildOfY( Object *obj, struct MUI_NListtree_TreeNode *x, struct MUI_NListtree_TreeNode *y )
 277 {
 278         do
 279         {
 280                 if ( y == x )
 281                 {
 282                         return( y );
 283                 }
 284         }
 285         while((y = GetParentNotRoot( obj, y)));
 286
 287         return( NULL );
 288 }
 289
 290
 291
 292 /*
 293 **      Allocates memory for each entry we create.
 294 */
 295 HOOKPROTONHNO(confunc, SIPTR, struct MUIP_NListtree_ConstructMessage *msg)
 296 {
 297         struct SampleArray *sa;
 298
 299         /*
 300         **      Allocate needed piece of memory for the new entry.
 301         */
 302         if((sa = (struct SampleArray *)AllocVec( sizeof( struct SampleArray) + strlen( msg->Name ) + 1, MEMF_CLEAR)))
 303         {
 304                 /*
 305                 **      Save the user data field right after the
 306                 **      array structure.
 307                 */
 308                 strcpy( (STRPTR)&sa[1], msg->Name );
 309                 sa->name = (STRPTR)&sa[1];
 310
 311                 sa->flags = (IPTR)msg->UserData;
 312         }
 313
 314         return( (SIPTR)sa );
 315 }
 316 MakeStaticHook(conhook, confunc);
 317
 318
 319 /*
 320 **      Free memory we just allocated above.
 321 */
 322 HOOKPROTONHNO(desfunc, LONG, struct MUIP_NListtree_DestructMessage *msg)
 323 {
 324         if ( msg->UserData != NULL )
 325         {
 326                 FreeVec( msg->UserData );
 327                 msg->UserData = NULL;
 328         }
 329
 330         return( 0 );
 331 }
 332 MakeStaticHook(deshook, desfunc);
 333
 334
 335 /*
 336 **      Compare hook function.
 337 */
 338 HOOKPROTONHNO(compfunc, LONG, struct MUIP_NListtree_CompareMessage *msg)
 339 {
 340         return( stricmp( msg->TreeNode1->tn_Name, msg->TreeNode2->tn_Name ) );
 341 }
 342 MakeStaticHook(comphook, compfunc);
 343
 344
 345 /*
 346 **      MultiTest hook function.
 347 */
 348 HOOKPROTONHNO(mtfunc, LONG, struct MUIP_NListtree_MultiTestMessage *msg)
 349 {
 350         if ( msg->TreeNode->tn_Flags & TNF_LIST )
 351                 return( FALSE );
 352
 353         return( TRUE );
 354 }
 355 MakeStaticHook(mthook, mtfunc);
 356
 357
 358 /*
 359 **      Format the entry data for displaying.
 360 */
 361 HOOKPROTONHNO(dspfunc, LONG, struct MUIP_NListtree_DisplayMessage *msg)
 362 {
 363         STATIC CONST_STRPTR t1 = "Newsgroups", t2 = "Flags", t3 = "subscribed", t4 = "\0", t5 = "Count";
 364         STATIC char buf[10];
 365
 366         if ( msg->TreeNode != NULL )
 367         {
 368                 /*
 369                 **      The user data is a pointer to a SampleArray struct.
 370                 */
 371                 struct SampleArray *a = (struct SampleArray *)msg->TreeNode->tn_User;
 372
 373                 snprintf( buf, sizeof(buf), "%3d", (unsigned int)(IPTR)msg->Array[-1] );
 374
 375                 *msg->Array++   = msg->TreeNode->tn_Name;
 376                 *msg->Array++   = (STRPTR)(( a->flags & 0x8000 ) ? t3 : t4);
 377                 *msg->Array++   = buf;
 378         }
 379         else
 380         {
 381                 *msg->Array++   = (STRPTR)t1;
 382                 *msg->Array++   = (STRPTR)t2;
 383                 *msg->Array++   = (STRPTR)t5;
 384
 385                 *msg->Preparse++        = (STRPTR)"\033b\033u";
 386                 *msg->Preparse++        = (STRPTR)"\033b\033u";
 387                 *msg->Preparse++        = (STRPTR)"\033b\033u";
 388         }
 389
 390         return( 0 );
 391 }
 392 MakeStaticHook(dsphook, dspfunc);
 393
 394
 395 /*
 396 **      Insert a new entry which name is given in
 397 **      the string gadget.
 398 */
 399 HOOKPROTONHNP(insertfunc, LONG, Object *obj)
 400 {
 401         STRPTR x = NULL;
 402
 403         /*
 404         **      Get user string.
 405         */
 406         get( st_string, MUIA_String_Contents, &x );
 407
 408         /*
 409         **      Insert the new entry after
 410         **      the active entry.
 411         */
 412         DoMethod( obj, MUIM_NListtree_Insert, x, 0, MUIV_NListtree_Insert_ListNode_Active,
 413                 MUIV_NListtree_Insert_PrevNode_Active, MUIV_NListtree_Insert_Flag_Active );
 414
 415         return( 0 );
 416 }
 417 MakeStaticHook(inserthook, insertfunc);
 418
 419
 420 /*
 421 **      Exchange two entries.
 422 */
 423 HOOKPROTONH(exchangefunc, LONG, Object *obj, ULONG **para)
 424 {
 425         STATIC struct MUI_NListtree_TreeNode *tn1, *tn2;
 426         STATIC LONG exchcnt = 0;
 427
 428         if ( ( exchcnt == 0 ) && ( (IPTR)*para == 42 ) )
 429         {
 430                 get( obj, MUIA_NListtree_Active, &tn1 );
 431
 432                 if ( tn1 != MUIV_NListtree_Active_Off )
 433                 {
 434                         nnset( tx_info3, MUIA_Text_Contents, "Select entry to exchange selected entry with." );
 435
 436                         exchcnt++;
 437                 }
 438         }
 439
 440         else if ( exchcnt == 1 )
 441         {
 442                 get( obj, MUIA_NListtree_Active, &tn2 );
 443
 444                 if ( ( tn2 != MUIV_NListtree_Active_Off ) && ( tn1 != tn2 ) )
 445                 {
 446                         if ( !IsXChildOfY( obj, tn1, tn2 ) && !IsXChildOfY( obj, tn1, tn2 ) )
 447                         {
 448                                 struct MUI_NListtree_ListNode *ln1;
 449
 450                                 if((ln1 = (struct MUI_NListtree_ListNode *)DoMethod( obj, MUIM_NListtree_GetEntry, tn1, MUIV_NListtree_GetEntry_Position_Parent, 0)))
 451                                 {
 452                                         DoMethod( obj, MUIM_NListtree_Exchange, ln1, tn1, MUIV_NListtree_Exchange_ListNode2_Active, MUIV_NListtree_Exchange_TreeNode2_Active, 0 );
 453
 454                                         nnset( tx_info3, MUIA_Text_Contents, "Entries successfully exchanged!" );
 455                                 }
 456                                 else
 457                                         nnset( tx_info3, MUIA_Text_Contents, "Something went wrong! Try again to select." );
 458                         }
 459                         else
 460                                 nnset( tx_info3, MUIA_Text_Contents, "You can not exchange with childs!" );
 461                 }
 462                 else
 463                         nnset( tx_info3, MUIA_Text_Contents, "You should not exchange an entry with itself!" );
 464
 465                 exchcnt = 0;
 466         }
 467
 468         return( 0 );
 469 }
 470 MakeStaticHook(exchangehook, exchangefunc);
 471
 472
 473 /*
 474 **      Rename the selected entry with the name is given in
 475 **      the string gadget.
 476 */
 477 HOOKPROTONHNP(renamefunc, LONG, Object *obj)
 478 {
 479         struct MUI_NListtree_TreeNode *tn = NULL;
 480         STRPTR x = NULL;
 481
 482         /*
 483         **      Get user string.
 484         */
 485         get( st_string, MUIA_String_Contents, &x );
 486         get( obj, MUIA_NListtree_Active, &tn );
 487
 488         /*
 489         **      Insert the new entry sorted (compare hook)
 490         **      into the active list node.
 491         */
 492         DoMethod( obj, MUIM_NListtree_Rename, tn,
 493                 x, 0 );
 494
 495         return( 0 );
 496 }
 497 MakeStaticHook(renamehook, renamefunc);
 498
 499
 500 /*
 501 **      Insert a new entry which name is given in
 502 **      the string gadget.
 503 */
 504 HOOKPROTONH(movefunc, LONG, Object *obj, ULONG **para)
 505 {
 506         STATIC struct MUI_NListtree_TreeNode *tn1, *tn2;
 507         STATIC LONG movecnt = 0;
 508
 509         if ( ( movecnt == 0 ) && ( (IPTR)*para == 42 ) )
 510         {
 511                 get( obj, MUIA_NListtree_Active, &tn1 );
 512
 513                 if ( tn1 != MUIV_NListtree_Active_Off )
 514                 {
 515                         nnset( tx_info3, MUIA_Text_Contents, "Select entry to insert after by simple click." );
 516
 517                         movecnt++;
 518                 }
 519         }
 520
 521         else if ( movecnt == 1 )
 522         {
 523                 get( obj, MUIA_NListtree_Active, &tn2 );
 524
 525                 if ( ( tn2 != MUIV_NListtree_Active_Off ) && ( tn1 != tn2 ) )
 526                 {
 527                         if ( !IsXChildOfY( obj, tn1, tn2 ) && !IsXChildOfY( obj, tn1, tn2 ) )
 528                         {
 529                                 struct MUI_NListtree_ListNode *ln1;
 530
 531                                 if((ln1 = (struct MUI_NListtree_ListNode *)DoMethod( obj, MUIM_NListtree_GetEntry, tn1, MUIV_NListtree_GetEntry_Position_Parent, 0)))
 532                                 {
 533                                         DoMethod( obj, MUIM_NListtree_Move, ln1, tn1, MUIV_NListtree_Move_NewListNode_Active, tn2, 0 );
 534
 535                                         nnset( tx_info3, MUIA_Text_Contents, "Entry successfully moved!" );
 536                                 }
 537                                 else
 538                                         nnset( tx_info3, MUIA_Text_Contents, "Something went wrong! Try again to select destination." );
 539                         }
 540                         else
 541                                 nnset( tx_info3, MUIA_Text_Contents, "You can not move childs!" );
 542                 }
 543                 else
 544                         nnset( tx_info3, MUIA_Text_Contents, "You should not move an entry to itself!" );
 545
 546                 movecnt = 0;
 547         }
 548
 549         return( 0 );
 550 }
 551 MakeStaticHook(movehook, movefunc);
 552
 553
 554 /*
 555 **      Insert a new entry which name is given in
 556 **      the string gadget.
 557 */
 558 HOOKPROTONH(copyfunc, LONG, Object *obj, ULONG **para)
 559 {
 560         STATIC struct MUI_NListtree_TreeNode *tn1, *tn2;
 561         STATIC LONG copycnt = 0;
 562
 563         if ( ( copycnt == 0 ) && ( (IPTR)*para == 42 ) )
 564         {
 565                 get( obj, MUIA_NListtree_Active, &tn1 );
 566
 567                 if ( tn1 != MUIV_NListtree_Active_Off )
 568                 {
 569                         nnset( tx_info3, MUIA_Text_Contents, "Select entry to insert after by simple click." );
 570
 571                         copycnt++;
 572                 }
 573         }
 574
 575         else if ( copycnt == 1 )
 576         {
 577                 get( obj, MUIA_NListtree_Active, &tn2 );
 578
 579                 if ( ( tn2 != MUIV_NListtree_Active_Off ) && ( tn1 != tn2 ) )
 580                 {
 581                         struct MUI_NListtree_ListNode *ln1;
 582
 583                         if((ln1 = (struct MUI_NListtree_ListNode *)DoMethod( obj, MUIM_NListtree_GetEntry, tn1, MUIV_NListtree_GetEntry_Position_Parent, 0)))
 584                         {
 585                                 DoMethod( obj, MUIM_NListtree_Copy, ln1, tn1, MUIV_NListtree_Copy_DestListNode_Active, tn2, 0 );
 586
 587                                 nnset( tx_info3, MUIA_Text_Contents, "Entry successfully copied!" );
 588                         }
 589                         else
 590                                 nnset( tx_info3, MUIA_Text_Contents, "Something went wrong! Try again to select destination." );
 591                 }
 592                 else
 593                         nnset( tx_info3, MUIA_Text_Contents, "You should not copy an entry to itself!" );
 594
 595                 copycnt = 0;
 596         }
 597
 598         return( 0 );
 599 }
 600 MakeStaticHook(copyhook, copyfunc);
 601
 602
 603 /*
 604 **      Move KeepStructure
 605 */
 606 HOOKPROTONH(moveksfunc, LONG, Object *obj, ULONG **para)
 607 {
 608         STATIC struct MUI_NListtree_TreeNode *tn1, *tn2;
 609         STATIC LONG movekscnt = 0;
 610
 611         if ( ( movekscnt == 0 ) && ( (IPTR)*para == 42 ) )
 612         {
 613                 get( obj, MUIA_NListtree_Active, &tn1 );
 614
 615                 if ( tn1 != MUIV_NListtree_Active_Off )
 616                 {
 617                         nnset( tx_info3, MUIA_Text_Contents, "Select entry to make KeepStructure move with." );
 618
 619                         movekscnt++;
 620                 }
 621         }
 622
 623         else if ( movekscnt == 1 )
 624         {
 625                 get( obj, MUIA_NListtree_Active, &tn2 );
 626
 627                 if ( ( tn2 != MUIV_NListtree_Active_Off ) && ( tn1 != tn2 ) )
 628                 {
 629                         struct MUI_NListtree_ListNode *ln1;
 630
 631                         if((ln1 = (struct MUI_NListtree_ListNode *)DoMethod( obj, MUIM_NListtree_GetEntry, tn1, MUIV_NListtree_GetEntry_Position_Parent, 0)))
 632                         {
 633                                 DoMethod( obj, MUIM_NListtree_Move, ln1, tn1, MUIV_NListtree_Move_NewListNode_Active, tn2, MUIV_NListtree_Move_Flag_KeepStructure );
 634
 635                                 nnset( tx_info3, MUIA_Text_Contents, "Entry successfully moved (structure keeped)" );
 636                         }
 637                         else
 638                                 nnset( tx_info3, MUIA_Text_Contents, "Something went wrong! Try again to select destination." );
 639                 }
 640                 else
 641                         nnset( tx_info3, MUIA_Text_Contents, "You should not move an entry to itself!" );
 642
 643                 movekscnt = 0;
 644         }
 645
 646         return( 0 );
 647 }
 648 MakeStaticHook(movekshook, moveksfunc);
 649
 650 /*
 651 **      Copy KeepStructure
 652 */
 653 HOOKPROTONH(copyksfunc, LONG, Object *obj, ULONG **para)
 654 {
 655         STATIC struct MUI_NListtree_TreeNode *tn1, *tn2;
 656         STATIC LONG copykscnt = 0;
 657
 658         if ( ( copykscnt == 0 ) && ( (IPTR)*para == 42 ) )
 659         {
 660                 get( obj, MUIA_NListtree_Active, &tn1 );
 661
 662                 if ( tn1 != MUIV_NListtree_Active_Off )
 663                 {
 664                         nnset( tx_info3, MUIA_Text_Contents, "Select entry to make KeepStructure copy with." );
 665
 666                         copykscnt++;
 667                 }
 668         }
 669
 670         else if ( copykscnt == 1 )
 671         {
 672                 get( obj, MUIA_NListtree_Active, &tn2 );
 673
 674                 if ( ( tn2 != MUIV_NListtree_Active_Off ) && ( tn1 != tn2 ) )
 675                 {
 676                         struct MUI_NListtree_ListNode *ln1;
 677
 678                         if((ln1 = (struct MUI_NListtree_ListNode *)DoMethod( obj, MUIM_NListtree_GetEntry, tn1, MUIV_NListtree_GetEntry_Position_Parent, 0)))
 679                         {
 680                                 DoMethod( obj, MUIM_NListtree_Copy, ln1, tn1, MUIV_NListtree_Copy_DestListNode_Active, tn2, MUIV_NListtree_Copy_Flag_KeepStructure );
 681
 682                                 nnset( tx_info3, MUIA_Text_Contents, "Entry successfully copied (structure keeped)" );
 683                         }
 684                         else
 685                                 nnset( tx_info3, MUIA_Text_Contents, "Something went wrong! Try again to select destination." );
 686                 }
 687                 else
 688                         nnset( tx_info3, MUIA_Text_Contents, "You should not copy an entry to itself!" );
 689
 690                 copykscnt = 0;
 691         }
 692
 693         return( 0 );
 694 }
 695 MakeStaticHook(copykshook, copyksfunc);
 696
 697
 698 HOOKPROTONHNO(fudf, LONG, struct MUIP_NListtree_FindUserDataMessage *msg)
 699 {
 700         nnset( tx_info1, MUIA_Text_Contents, "FindUserData Hook passed!" );
 701         return( strncmp( (STRPTR)msg->User, (STRPTR)msg->UserData, strlen( (STRPTR)msg->User ) ) );
 702 }
 703 MakeStaticHook(fudh, fudf);
 704
 705 /*
 706 **      Find the specified tree node by name.
 707 */
 708 HOOKPROTONHNP(findnamefunc, LONG, Object *obj)
 709 {
 710         struct MUI_NListtree_TreeNode *tn;
 711         STRPTR x = NULL;
 712
 713         /*
 714         **      Let us see, which string the user wants to search for...
 715         */
 716         get( st_string, MUIA_String_Contents, &x );
 717
 718         /*
 719         **      Is it somewhere in the tree?
 720         */
 721         if((tn = (struct MUI_NListtree_TreeNode *)DoMethod(obj, MUIM_NListtree_FindUserData, MUIV_NListtree_FindUserData_ListNode_Root, x, MUIV_NListtree_FindUserData_Flag_Activate)))
 722         {
 723                 /*
 724                 **      Found! Inform the user.
 725                 */
 726                 nnset( tx_info3, MUIA_Text_Contents, "Found your node!" );
 727         }
 728         else
 729         {
 730                 /*
 731                 **      Not found. Inform the user.
 732                 */
 733                 nnset( tx_info3, MUIA_Text_Contents, "NOT found specified node!" );
 734         }
 735
 736         return( 0 );
 737 }
 738 MakeStaticHook(findnamehook, findnamefunc);
 739
 740
 741 /*
 742 **      Sort the active list.
 743 */
 744 HOOKPROTONHNP(sortfunc, LONG, Object *obj)
 745 {
 746         clock_t start, end;
 747         LONG lastactive = 0;
 748
 749         get( obj, MUIA_NListtree_Active, &lastactive );
 750         set( obj, MUIA_NListtree_Active, MUIV_NListtree_Active_Off );
 751
 752         start = clock();
 753         DoMethod( obj, MUIM_NListtree_Sort, lastactive, 0 );
 754         end = clock();
 755
 756         set( obj, MUIA_NListtree_Active, lastactive );
 757
 758         DoMethod( tx_info3, MUIM_SetAsString, MUIA_Text_Contents, "Sort took %ld.%03lds", ( end - start ) / CLOCKS_PER_SEC, ( end - start ) % CLOCKS_PER_SEC );
 759
 760         return( 0 );
 761 }
 762 MakeStaticHook(sorthook, sortfunc);
 763
 764
 765 /*
 766 **      Find the specified tree node by name.
 767 */
 768 HOOKPROTONHNP(getnrfunc, LONG, Object *obj)
 769 {
 770         LONG temp, temp2;
 771
 772         temp = DoMethod( obj, MUIM_NListtree_GetNr,
 773                 MUIV_NListtree_GetNr_TreeNode_Active, MUIV_NListtree_GetNr_Flag_CountLevel );
 774
 775         if ( temp == 1 )
 776                 DoMethod( tx_info1, MUIM_SetAsString, MUIA_Text_Contents, "1 entry in parent node." );
 777         else
 778                 DoMethod( tx_info1, MUIM_SetAsString, MUIA_Text_Contents, "%ld entries in parent node.", temp );
 779
 780
 781         temp = DoMethod( obj, MUIM_NListtree_GetNr,
 782                 MUIV_NListtree_GetNr_TreeNode_Active, MUIV_NListtree_GetNr_Flag_CountAll );
 783
 784         if ( temp == 1 )
 785                 DoMethod( tx_info2, MUIM_SetAsString, MUIA_Text_Contents, "1 entry total." );
 786         else
 787                 DoMethod( tx_info2, MUIM_SetAsString, MUIA_Text_Contents, "%ld entries total.", temp );
 788
 789
 790         temp = DoMethod( obj, MUIM_NListtree_GetNr,
 791                 MUIV_NListtree_GetNr_TreeNode_Active, 0 );
 792
 793         temp2 = DoMethod( obj, MUIM_NListtree_GetNr,
 794                 MUIV_NListtree_GetNr_TreeNode_Active, MUIV_NListtree_GetNr_Flag_Visible );
 795
 796         DoMethod( tx_info3, MUIM_SetAsString, MUIA_Text_Contents, "Active entry pos: %ld (visible: %ld).", temp, temp2 );
 797
 798         return( 0 );
 799 }
 800 MakeStaticHook(getnrhook, getnrfunc);
 801
 802 /*
 803 **      Find the specified tree node by name.
 804 */
 805 HOOKPROTONHNP(numselfunc, LONG, Object *obj)
 806 {
 807         LONG temp = 0;
 808
 809         DoMethod( obj, MUIM_NListtree_Select, MUIV_NListtree_Select_All,
 810                 MUIV_NListtree_Select_Ask, 0, &temp );
 811
 812         if ( temp == 1 )
 813                 DoMethod( tx_info1, MUIM_SetAsString, MUIA_Text_Contents, "1 node selected." );
 814         else
 815                 DoMethod( tx_info1, MUIM_SetAsString, MUIA_Text_Contents, "%ld nodes selected.", temp );
 816
 817         {
 818                 struct MUI_NListtree_TreeNode *tn;
 819
 820                 tn = (struct MUI_NListtree_TreeNode *)MUIV_NListtree_NextSelected_Start;
 821
 822                 for (;;)
 823                 {
 824                         DoMethod( obj, MUIM_NListtree_NextSelected, &tn );
 825
 826                         if ( (IPTR)tn == (IPTR)MUIV_NListtree_NextSelected_End )
 827                                 break;
 828
 829                         D(bug( "Next TreeNode: 0x%08lx - %s\n", tn, tn->tn_Name ) );
 830                 }
 831
 832                 D(bug( "\n" ) );
 833
 834                 tn = (struct MUI_NListtree_TreeNode *)MUIV_NListtree_PrevSelected_Start;
 835
 836                 for (;;)
 837                 {
 838                         DoMethod( obj, MUIM_NListtree_PrevSelected, &tn );
 839
 840                         if ( (IPTR)tn == (IPTR)MUIV_NListtree_PrevSelected_End )
 841                                 break;
 842
 843                         D(bug( "Prev TreeNode: 0x%08lx - %s\n", tn, tn->tn_Name ) );
 844                 }
 845         }
 846
 847         return( 0 );
 848 }
 849 MakeStaticHook(numselhook, numselfunc);
 850
 851 /*
 852 **      Test func
 853 */
 854 HOOKPROTONHNP(testfunc, LONG, Object *obj)
 855 {
 856         SIPTR id;
 857         ULONG num;
 858
 859         id = MUIV_NListtree_NextSelected_Start;
 860
 861         for(;;)
 862         {
 863                 DoMethod( obj, MUIM_NListtree_NextSelected, &id );
 864
 865                 if(id == (SIPTR)MUIV_NListtree_NextSelected_End )
 866                         break;
 867
 868                 //GetAttr( MUIA_List_Entries, obj, &num );
 869
 870                 num = DoMethod( obj, MUIM_NListtree_GetNr,
 871                                 MUIV_NListtree_GetNr_TreeNode_Active, MUIV_NListtree_GetNr_Flag_CountAll );
 872
 873                 if ( num > 1 )
 874                         DoMethod( obj, MUIM_NListtree_Remove, MUIV_NListtree_Remove_ListNode_Active, id, 0 );
 875                 else
 876                         break;
 877         }
 878
 879         return( 0 );
 880 }
 881 MakeStaticHook(testhook, testfunc);
 882
 883
 884 #if defined(__amigaos4__)
 885 #define GETINTERFACE(iface, base)       (iface = (APTR)GetInterface((struct Library *)(base), "main", 1L, NULL))
 886 #define DROPINTERFACE(iface)                    (DropInterface((struct Interface *)iface), iface = NULL)
 887 #else
 888 #define GETINTERFACE(iface, base)       TRUE
 889 #define DROPINTERFACE(iface)
 890 #endif
 891
 892 /*
 893 **      Main
 894 */
 895 int main(UNUSED int argc, UNUSED char *argv[])
 896 {
 897         ULONG signals;
 898         static const char *const UsedClasses[] = {
 899                 "NList.mcc",
 900                 "NListtree.mcc",
 901                 "NListviews.mcc",
 902                 NULL
 903         };
 904
 905         /*
 906         **      Is MUI V19 available?
 907         */
 908         if((IntuitionBase = (APTR)OpenLibrary("intuition.library", 36)) &&
 909                 GETINTERFACE(IIntuition, IntuitionBase))
 910         if((MUIMasterBase = OpenLibrary("muimaster.library", 19)) &&
 911                 GETINTERFACE(IMUIMaster, MUIMasterBase))
 912         {
 913                 /*
 914                 **      Create application object.
 915                 */
 916                 app = ApplicationObject,
 917                         MUIA_Application_Title,       "NListtree-Demo",
 918                         MUIA_Application_Version,     "$VER: NListtree-Demo 1.0 (" __DATE__ ")",
 919                         MUIA_Application_Copyright,   "(C) 2001-2014 NList Open Source Team",
 920                         MUIA_Application_Author,      "NList Open Source Team",
 921                         MUIA_Application_Description, "Demonstration program for MUI class NListtree.mcc",
 922                         MUIA_Application_Base,        "NLISTTREEDEMO",
 923                         MUIA_Application_UsedClasses, UsedClasses,
 924
 925                         /*
 926                         **      Build the window.
 927                         */
 928                         SubWindow, window = WindowObject,
 929                                 MUIA_Window_Title,                      "NListtree-Demo",
 930                                 MUIA_Window_ID,                         MAKE_ID( 'N', 'L', 'T', 'R' ),
 931                                 MUIA_Window_AppWindow,          TRUE,
 932                                 WindowContents,                         VGroup,
 933
 934                                         /*
 935                                         **      Create a NListview embedded NListtree object
 936                                         */
 937                                         Child, NListviewObject,
 938                                                 MUIA_ShortHelp,                 "The NListtree object...",
 939                                                 MUIA_NListview_NList,   lt_nodes = NListtreeObject,
 940                                                         InputListFrame,
 941                                                         MUIA_CycleChain,                                TRUE,
 942                                                         MUIA_NList_MinLineHeight,               18,
 943                                                         MUIA_NListtree_MultiSelect,             MUIV_NListtree_MultiSelect_Shifted,
 944                                                         MUIA_NListtree_MultiTestHook,   &mthook,
 945                                                         MUIA_NListtree_DisplayHook,             &dsphook,
 946                                                         MUIA_NListtree_ConstructHook,   &conhook,
 947                                                         MUIA_NListtree_DestructHook,    &deshook,       /* This is the same as MUIV_NListtree_CompareHook_LeavesMixed. */
 948                                                         MUIA_NListtree_CompareHook,             &comphook,
 949                                                         MUIA_NListtree_DoubleClick,             MUIV_NListtree_DoubleClick_Tree,
 950                                                         MUIA_NListtree_EmptyNodes,              FALSE,
 951                                                         MUIA_NListtree_TreeColumn,              0,
 952                                                         MUIA_NListtree_DragDropSort,    TRUE,
 953                                                         MUIA_NListtree_Title,                   TRUE,
 954                                                         MUIA_NListtree_Format,                  ",,",
 955                                                         MUIA_NListtree_FindUserDataHook,&fudh,
 956                                                         //MUIA_NListtree_NoRootTree,            TRUE,
 957                                                 End,
 958                                         End,
 959
 960                                         /*
 961                                         **      Build some controls.
 962                                         */
 963                                         Child, tx_info1 = TextObject,
 964                                                 MUIA_Background, MUII_TextBack,
 965                                                 TextFrame,
 966                                         End,
 967
 968                                         Child, tx_info2 = TextObject,
 969                                                 MUIA_Background, MUII_TextBack,
 970                                                 TextFrame,
 971                                         End,
 972
 973                                         Child, tx_info3 = TextObject,
 974                                                 MUIA_Background, MUII_TextBack,
 975                                                 TextFrame,
 976                                         End,
 977
 978                                         Child, ColGroup( 2 ),
 979                                                 Child, FreeKeyLabel( "TreeCol:", 'c' ),
 980                                                 Child, sl_treecol       = Slider( 0, 2, 0 ),
 981                                         End,
 982
 983                                         Child, HGroup,
 984                                                 Child, st_string = StringObject,
 985                                                         StringFrame,
 986                                                         MUIA_String_MaxLen, 50,
 987                                                 End,
 988                                         End,
 989
 990
 991                                         Child, ColGroup( 4 ),
 992                                                 Child, bt_open          = KeyButton( "Open",            'o' ),
 993                                                 Child, bt_close         = KeyButton( "Close",           'c' ),
 994                                                 Child, bt_expand        = KeyButton( "Expand",          'e' ),
 995                                                 Child, bt_collapse      = KeyButton( "Collapse",        'a' ),
 996
 997                                                 Child, bt_insert        = KeyButton( "Insert",          'i' ),
 998                                                 Child, bt_remove        = KeyButton( "Remove",          'r' ),
 999                                                 Child, bt_exchange      = KeyButton( "Exchange",        'x' ),
1000                                                 Child, bt_rename        = KeyButton( "Rename",          'r' ),
1001
1002                                                 Child, bt_move          = KeyButton( "Move",            'm' ),
1003                                                 Child, bt_copy          = KeyButton( "Copy",            'y' ),
1004                                                 Child, bt_moveks        = KeyButton( "Move KS",         'v' ),
1005                                                 Child, bt_copyks        = KeyButton( "Copy KS",         'k' ),
1006
1007                                                 Child, bt_find          = KeyButton( "FindName",        'f' ),
1008                                                 Child, bt_parent        = KeyButton( "Parent",          'p' ),
1009                                                 Child, bt_sort          = KeyButton( "Sort",            's' ),
1010                                                 Child, bt_getnr         = KeyButton( "GetNr",           'n' ),
1011
1012                                                 Child, bt_redraw        = KeyButton( "Redraw",          'w' ),
1013                                                 Child, bt_selected      = KeyButton( "Selected",        'd' ),
1014                                                 Child, bt_seltogg       = KeyButton( "Sel Togg",        't' ),
1015                                                 Child, bt_showtree      = KeyButton( "Show tree",       'h' ),
1016
1017                                                 Child, bt_test          = KeyButton( "Test", ' ' ),
1018                                                 Child, bt_test2         = KeyButton( "Test2", ' ' ),
1019                                                 Child, bt_test3         = KeyButton( "Test3", ' ' ),
1020                                                 Child, bt_test4         = KeyButton( "Test4", ' ' ),
1021                                         End,
1022
1023                                 End,
1024
1025                         End,
1026                 End;
1027
1028
1029                 if( app )
1030                 {
1031                         /*
1032                         **      generate notifications
1033                         */
1034                         DoMethod( window, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
1035                                 app, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
1036
1037                         /*
1038                         **      open/close/expand/collapse
1039                         */
1040                         DoMethod( bt_open, MUIM_Notify, MUIA_Pressed, FALSE,
1041                                 lt_nodes, 4, MUIM_NListtree_Open, MUIV_NListtree_Open_ListNode_Active, MUIV_NListtree_Open_TreeNode_Active, 0 );
1042
1043                         DoMethod( bt_close, MUIM_Notify, MUIA_Pressed, FALSE,
1044                                 lt_nodes, 4, MUIM_NListtree_Close, MUIV_NListtree_Close_ListNode_Active, MUIV_NListtree_Close_TreeNode_Active, 0 );
1045
1046                         DoMethod( bt_expand, MUIM_Notify, MUIA_Pressed, FALSE,
1047                                 lt_nodes, 4, MUIM_NListtree_Open, MUIV_NListtree_Open_ListNode_Root, MUIV_NListtree_Open_TreeNode_All, 0 );
1048
1049                         DoMethod( bt_collapse, MUIM_Notify, MUIA_Pressed, FALSE,
1050                                 lt_nodes, 4, MUIM_NListtree_Close, MUIV_NListtree_Close_ListNode_Root, MUIV_NListtree_Close_TreeNode_All, 0 );
1051
1052
1053
1054                         /*
1055                         **      insert/remove/exchange/rename
1056                         */
1057                         DoMethod( bt_insert, MUIM_Notify, MUIA_Pressed, FALSE,
1058                                 lt_nodes, 2, MUIM_CallHook, &inserthook );
1059
1060                         DoMethod( bt_remove, MUIM_Notify, MUIA_Pressed, FALSE,
1061                                 lt_nodes, 4, MUIM_NListtree_Remove, MUIV_NListtree_Remove_ListNode_Root, MUIV_NListtree_Remove_TreeNode_Selected, 0 );
1062
1063                         DoMethod( bt_exchange, MUIM_Notify, MUIA_Pressed, FALSE,
1064                                 lt_nodes, 3, MUIM_CallHook, &exchangehook, 42 );
1065
1066                         DoMethod( lt_nodes, MUIM_Notify, MUIA_NListtree_Active, MUIV_EveryTime,
1067                                 lt_nodes, 3, MUIM_CallHook, &exchangehook, 0 );
1068
1069                         DoMethod( bt_rename, MUIM_Notify, MUIA_Pressed, FALSE,
1070                                 lt_nodes, 2, MUIM_CallHook, &renamehook );
1071
1072
1073                         /*
1074                         **      move/copy/moveks/copyks
1075                         */
1076                         DoMethod( bt_move, MUIM_Notify, MUIA_Pressed, FALSE,
1077                                 lt_nodes, 3, MUIM_CallHook, &movehook, 42 );
1078
1079                         DoMethod( lt_nodes, MUIM_Notify, MUIA_NListtree_Active, MUIV_EveryTime,
1080                                 lt_nodes, 3, MUIM_CallHook, &movehook, 0 );
1081
1082                         DoMethod( bt_copy, MUIM_Notify, MUIA_Pressed, FALSE,
1083                                 lt_nodes, 3, MUIM_CallHook, &copyhook, 42 );
1084
1085                         DoMethod( lt_nodes, MUIM_Notify, MUIA_NListtree_Active, MUIV_EveryTime,
1086                                 lt_nodes, 3, MUIM_CallHook, &copyhook, 0 );
1087
1088                         DoMethod( bt_moveks, MUIM_Notify, MUIA_Pressed, FALSE,
1089                                 lt_nodes, 3, MUIM_CallHook, &movekshook, 42 );
1090
1091                         DoMethod( lt_nodes, MUIM_Notify, MUIA_NListtree_Active, MUIV_EveryTime,
1092                                 lt_nodes, 3, MUIM_CallHook, &movekshook, 0 );
1093
1094                         DoMethod( bt_copyks, MUIM_Notify, MUIA_Pressed, FALSE,
1095                                 lt_nodes, 3, MUIM_CallHook, &copykshook, 42 );
1096
1097                         DoMethod( lt_nodes, MUIM_Notify, MUIA_NListtree_Active, MUIV_EveryTime,
1098                                 lt_nodes, 3, MUIM_CallHook, &copykshook, 0 );
1099
1100
1101                         /*
1102                         **      find/parent/sort/getnr
1103                         */
1104                         DoMethod( bt_find, MUIM_Notify, MUIA_Pressed, FALSE,
1105                                 lt_nodes, 2, MUIM_CallHook, &findnamehook );
1106
1107                         DoMethod( bt_parent, MUIM_Notify, MUIA_Pressed, FALSE,
1108                                 lt_nodes, 3, MUIM_Set, MUIA_NListtree_Active, MUIV_NListtree_Active_Parent );
1109
1110                         DoMethod( bt_sort, MUIM_Notify, MUIA_Pressed, FALSE,
1111                                 lt_nodes, 2, MUIM_CallHook, &sorthook );
1112
1113                         /*
1114                         DoMethod( bt_sort, MUIM_Notify, MUIA_Pressed, FALSE,
1115                                 lt_nodes, 3, MUIM_NListtree_Sort, MUIV_NListtree_Sort_TreeNode_Active, 0 );
1116                         */
1117
1118                         DoMethod( bt_getnr, MUIM_Notify, MUIA_Pressed, FALSE,
1119                                 lt_nodes, 2, MUIM_CallHook, &getnrhook );
1120
1121
1122                         /*
1123                         **      redraw/selected/seltogg/showtree
1124                         */
1125                         DoMethod( bt_redraw, MUIM_Notify, MUIA_Pressed, FALSE,
1126                                 lt_nodes, 3, MUIM_NListtree_Redraw, MUIV_NListtree_Redraw_All );
1127
1128                         DoMethod( bt_selected, MUIM_Notify, MUIA_Pressed, FALSE,
1129                                 lt_nodes, 2, MUIM_CallHook, &numselhook );
1130
1131                         DoMethod( bt_seltogg, MUIM_Notify, MUIA_Pressed, FALSE,
1132                                 lt_nodes, 5, MUIM_NListtree_Select, MUIV_NListtree_Select_All, MUIV_NListtree_Select_Toggle, 0, NULL );
1133
1134                         DoMethod( bt_showtree, MUIM_Notify, MUIA_Pressed, FALSE,
1135                                 lt_nodes, 3, MUIM_Set, MUIA_NListtree_ShowTree, MUIV_NListtree_ShowTree_Toggle );
1136
1137
1138                         /*
1139                         **      misc
1140                         */
1141                         DoMethod( sl_treecol, MUIM_Notify, MUIA_Slider_Level, MUIV_EveryTime,
1142                                 lt_nodes, 3, MUIM_Set, MUIA_NListtree_TreeColumn, MUIV_TriggerValue );
1143
1144                         DoMethod( lt_nodes, MUIM_Notify, MUIA_NListtree_Active, MUIV_EveryTime,
1145                                 tx_info1, 4, MUIM_SetAsString, MUIA_Text_Contents, "Active node: 0x%08lx", MUIV_TriggerValue );
1146
1147                         DoMethod( lt_nodes, MUIM_Notify, MUIA_NListtree_ActiveList, MUIV_EveryTime,
1148                                 tx_info2, 4, MUIM_SetAsString, MUIA_Text_Contents, "Active list: 0x%08lx", MUIV_TriggerValue );
1149
1150                         DoMethod( lt_nodes, MUIM_Notify, MUIA_NListtree_DoubleClick, MUIV_EveryTime,
1151                                 tx_info3, 4, MUIM_SetAsString, MUIA_Text_Contents, "Double clicked on node: 0x%08lx", MUIV_TriggerValue );
1152
1153                         DoMethod( lt_nodes, MUIM_Notify, MUIA_NListtree_SelectChange, TRUE,
1154                                 tx_info3, 3, MUIM_SetAsString, MUIA_Text_Contents, "Selection state changed" );
1155
1156
1157                         /*
1158                         **      test
1159                         */
1160                         DoMethod( bt_test, MUIM_Notify, MUIA_Pressed, FALSE,
1161                                 lt_nodes, 2, MUIM_CallHook, &testhook );
1162
1163
1164
1165                         /*
1166                         **      Open the window.
1167                         **
1168                         */
1169                         set( window, MUIA_Window_Open, TRUE );
1170
1171
1172                         /*
1173                         **      Set the tree into quiet state.
1174                         */
1175                         set( lt_nodes, MUIA_NListtree_Quiet, TRUE );
1176
1177
1178                         /*
1179                         **      Insert sample nodes.
1180                         */
1181                         DrawSampleTree( lt_nodes );
1182
1183
1184                         /*
1185                         **      Set the tree back to normal state.
1186                         */
1187                         set( lt_nodes, MUIA_NListtree_Quiet, FALSE );
1188
1189                         /*
1190                         **      Minimal input loop.
1191                         */
1192                         while((LONG)DoMethod( app, MUIM_Application_NewInput, &signals ) != (LONG)MUIV_Application_ReturnID_Quit )
1193                         {
1194                                 if ( signals )
1195                                 {
1196                                         signals = Wait( signals | SIGBREAKF_CTRL_C );
1197
1198                                         if ( signals & SIGBREAKF_CTRL_C )
1199                                                 break;
1200                                 }
1201                         }
1202
1203                         /*
1204                         **      Clear the list.
1205                         */
1206                         DoMethod( lt_nodes, MUIM_NListtree_Clear, NULL, 0 );
1207
1208
1209                         /*
1210                         **      Close the window.
1211                         */
1212                         set( window, MUIA_Window_Open, FALSE );
1213
1214
1215                         /*
1216                         **      Shutdown
1217                         */
1218                         MUI_DisposeObject( app );
1219                 }
1220                 else
1221                         printf( "Failed to create Application.\n" );
1222         }
1223
1224         if(MUIMasterBase)
1225   {
1226     DROPINTERFACE(IMUIMaster);
1227                 CloseLibrary(MUIMasterBase);
1228   }
1229
1230         if(IntuitionBase)
1231   {
1232     DROPINTERFACE(IIntuition);
1233                 CloseLibrary((struct Library *)IntuitionBase);
1234   }
1235
1236         return( 0 );
1237 }
1238
1239