Exemple #1
0
/*
 *  UI_UtilOneLinePlus       ALIGN CONTROLS TO ONE LINE
 */
void UI_UtilOneLinePlus( LWControl *con1, LWControl *con2, LWControl *con3,
                         LWControl *con4, LWControl *con5, LWControl *con6, int spc )
{
	int          x, y;

	if(con1 && con2)
	{
		x = CON_X(con1);
		y = CON_Y(con1);
		x += CON_W(con1) + spc;
		MOVE_CON(con2,x,y);
		if(!con3) return;
		x += CON_W(con2) + spc;
		MOVE_CON(con3,x,y);
		if(!con4) return;
		x += CON_W(con3) + spc;
		MOVE_CON(con4,x,y);
		if(!con5) return;
		x += CON_W(con4) + spc;
		MOVE_CON(con5,x,y);
		if(!con6) return;
		x += CON_W(con5) + spc;
		MOVE_CON(con6,x,y);
	}
}
Exemple #2
0
static void create_controls( ConvolveInst *inst )
{
   const LWDisplayMetrics *dm;
   int x, y, dx, dy, w, i, pw, ph;


   /* create a control */

   ctl[ 0 ] = FLOAT_CTL( panf, panel, "" );

   /* find out how much vertical space the panel wants for drawing its
      own decorations */

   ph = PAN_GETH( panf, panel );
   ph -= CON_H( ctl[ 0 ] );

   /* create the rest of the controls */

   for ( i = 1; i < 9; i++ )
      ctl[ i ] = FLOAT_CTL( panf, panel, "" );

   ctl[ 9 ] = WPOPUP_CTL( panf, panel, "Presets", preset, 150 );

   /* position all of the controls */

   x  = CON_X( ctl[ 0 ] );
   y  = CON_Y( ctl[ 0 ] );
   dx = CON_HOTW( ctl[ 0 ] ) + 8;
   dy = CON_HOTH( ctl[ 0 ] ) + 4;

   for ( i = 1; i < 9; i++ )
      MOVE_CON( ctl[ i ], x + dx * ( i % 3 ), y + dy * ( i / 3 ));

   w = CON_W( ctl[ 9 ] );
   MOVE_CON( ctl[ 9 ], x + 3 * dx - w, y + 10 * dy / 3 );

   /* now that we know how much room the controls will take up, set the
      height of the panel and center it */

   ph += CON_Y( ctl[ 9 ] );
   ph += CON_HOTH( ctl[ 9 ] );
   PAN_SETH( panf, panel, ph - 6 );

   pw = PAN_GETW( panf, panel );
   dm = panf->drawFuncs->dispMetrics();
   MOVE_PAN( panf, panel, ( dm->width - pw ) / 2, ( dm->height - ph ) / 2 );

   /* initialize the controls */

   set_kernctl( inst );
   SET_INT( ctl[ 9 ], pindex );

   /* set the control event callbacks */

   CON_SETEVENT( ctl[ 9 ], handle_preset, inst );
}
Exemple #3
0
// MakeRegisterPanel():
//  Creates the Register Panel
bool SimplifyDongle::MakeRegisterPanel() {
  if( simp_int == NULL )
    return false;

  // Create the Panel
  register_panel = simp_int->panel_funcs->Create( "Simplify Registration" );

  try {
    if( !( dongle_id = STRRO_CTL( simp_int->panel_funcs->orig_struct, register_panel,
                                  "Dongle ID", 43 ) ) )
      throw false;

    if( !( reg_code = STR_CTL( simp_int->panel_funcs->orig_struct, register_panel,
                               "Reg Code", 43 ) ) )
      throw false;

    if( !( register_now = WBUTTON_CTL( simp_int->panel_funcs->orig_struct, register_panel,
                                       "Register Now", 150 ) ) )
      throw false;

    // Position some things
    MOVE_CON( dongle_id, 25, 212 );
    PanelTools::AlignLabels( dongle_id, reg_code );

    PAN_SETW( simp_int->panel_funcs->orig_struct, register_panel, 400 );
    PAN_SETH( simp_int->panel_funcs->orig_struct, register_panel, 350 );

    PanelTools::PutUnder( reg_code, register_now );

    int pw = PAN_GETW( simp_int->panel_funcs->orig_struct, register_panel );
    int w  = CON_W( register_now );
    int y  = CON_Y( register_now );
    MOVE_CON( register_now, (pw/2 - w/2), y );

    // Default Values
    char buffer[10];
    sprintf( buffer, "%ld", GetDongleID() );
    SET_STR( dongle_id, buffer, strlen( buffer ) );

    // Listener Functions
    CON_SETEVENT( register_now, OnRegisterNow, this );
    CON_SETEVENT( reg_code,     OnRegisterNow, this );

    // Set the Draw Functions
    simp_int->panel_funcs->Set( register_panel, PAN_USERDRAW, DrawRegisterPanel );

    return true;
  } catch( bool a ) {
    if( !a ) {
      simp_int->message->Error("Error creating interface controls; aborting" );
      return false;
    }
  }

  return true;
}
Exemple #4
0
// MakeKeySelectionControls():
bool FreeKeyInterface::MakeKeySelectionControls() {
  try {
    int x = CON_HOTW( select_info_area );
    int y = CON_HOTH( select_info_area );

    // Keyframe Selection Info
    if( !( key_select_info_area = AREA_CTL( panel_funcs->orig_struct, main_panel,
                                            "", x, y ) ) )
      throw false;

    x = CON_X( select_info_area );
    y = CON_Y( select_info_area );
    MOVE_CON( key_select_info_area, x, y );

    // Set the Draw Functions
    ival.intv.value = (int)&DrawKeySelectInfo;
    (*key_select_info_area->set)( key_select_info_area, CTL_USERDRAW, &ival );

    return true;
  } catch( bool ) {
    return false;
  }

  return true;
}
Exemple #5
0
/*
 *  UI_UtilEndLine        ALIGN CONTROLS TO ONE LINE FROM END
 */
void UI_UtilVAlign( int lw, LWControl *con )
{
	int          x, y;

	if(con)
	{
		x = CON_X(con);
		x += lw - CON_LW(con);
		y = CON_Y(con);
		MOVE_CON(con,x,y);
	}
}
Exemple #6
0
/*
 *  UI_UtilEndLine        ALIGN CONTROLS TO ONE LINE FROM END
 */
void UI_UtilEndLine( LWControl *con1, LWControl *con2, LWControl *con3,
                     LWControl *con4, LWControl *con5, LWControl *con6, int xw )
{
	int          x, y;

	if(con1 && con2)
	{
		x  = xw;
		x -= CON_W(con1);
		y  = CON_Y(con1);
		MOVE_CON(con1,x,y);
		if(!con2) return;
		x -= CON_W(con2);
		MOVE_CON(con2,x,y);
		if(!con3) return;
		x -= CON_W(con3);
		MOVE_CON(con3,x,y);
		if(!con4) return;
		x -= CON_W(con4);
		MOVE_CON(con4,x,y);
		if(!con5) return;
		x -= CON_W(con5);
		MOVE_CON(con5,x,y);
		if(!con6) return;
		x -= CON_W(con6);
		MOVE_CON(con6,x,y);
	}
}
Exemple #7
0
// MakeGroupControls():
bool FreeKeyInterface::MakeGroupControls() {
  try {
    int x, y;

    // Group Controls
    if( !( group_name = STR_CTL( panel_funcs->orig_struct, main_panel,
                                 "Group Name", 75 ) ) )
      throw false;

    if( !( group_delete = WBUTTON_CTL( panel_funcs->orig_struct, main_panel,
                                       "Del", 50 ) ) )
      throw false;

    if( !( group_edit_mode = WPOPUP_CTL( panel_funcs->orig_struct, main_panel,
                                         "Modify", group_edit_text, 250 ) ) )
      throw false;

    if( !( group_edit_apply = WBUTTON_CTL( panel_funcs->orig_struct, main_panel,
                                           "Apply", 100 ) ) )
      throw false;

    PanelTools::PutUnder( tool_options_tabs, group_name );
    x = CON_X( group_name );
    y = CON_Y( group_name );
    MOVE_CON( group_name, x, y+4 );

    PanelTools::PutOnLineWith( group_name, group_delete    );
    PanelTools::AlignLabels( group_name, group_edit_mode );
    PanelTools::PutOnLineWith( group_edit_mode, group_edit_apply );

    // Event Handler Functions
    CON_SETEVENT( group_name,              OnGroupName,          this );
    CON_SETEVENT( group_delete,            OnGroupDel,           this );
    CON_SETEVENT( group_edit_apply,        OnGroupEditApply,     this );

    return true;
  } catch( bool ) {
    return false;
  }

  return true;
}
Exemple #8
0
// MakeProcessPanel():
bool FreeKeyInterface::MakeProcessPanel() {
  // Create the Panel
  process_panel = panel_funcs->Create( main_title );

  if( !process_panel ) {                    // Make sure the panel was created
    message->Error("Error creating Processing Panel, aborting" );
    return false;
  }

try {
  // Progress Bar Area
  if( !( progress_bar = CANVAS_CTL( panel_funcs->orig_struct, process_panel,
                                  "", 320, 20 ) ) )
    throw false;

  int x = CON_X(progress_bar);
  int y = CON_Y(progress_bar);
  MOVE_CON( progress_bar, x+5, y + 20 );

  // Set the Panel Size
  //PAN_SETW( panel_funcs->orig_struct, progress_panel, 300 );
  PAN_SETH( panel_funcs->orig_struct, process_panel, 110 );
  
  // Set the Draw Functions
  panel_funcs->Set( process_panel, PAN_USERDRAW, DrawProcessPanel );

  ival.intv.value = (int)&DrawProgressBar;
  (*progress_bar->set)( progress_bar, CTL_USERDRAW, &ival );

  return true;

} catch( bool a ) {
  if( !a ) {
    message->Error("Error creating About Box interface controls; aborting" );
    return false;
  }
}

return true;
}
Exemple #9
0
// MakeMainPanel():
bool SimplifyGlobalInterface::MakeMainPanel() {
  // Set up Main Title String
  sprintf( main_title_bar, "Simplify Global Control V%d.%d from TM Productions",
           Simplify_Version, Simplify_Revision );

  // Create the Panel
  main_panel = panel_funcs->Create( main_title_bar );

  if( !main_panel ) {                    // Make sure the panel was created
    message->Error("Error creating main panel, aborting" );
    return false;
  }

  int x, y, w, h;
  try {
    // Source/Output Paths
    if( !( source_scene = FILE_CTL( panel_funcs->orig_struct, main_panel,
                                    "Source Scene", 70 ) ) )
      throw false;

    if( !( output_scene = FILE_CTL( panel_funcs->orig_struct, main_panel,
                                    "Output Scene", 70 ) ) )
      throw false;

    x = CON_X( source_scene );
    y = CON_X( source_scene );
    MOVE_CON( source_scene, x+16, y+70 );

    SET_STR( source_scene,  source_filename, strlen( source_filename ) );
    SET_STR( output_scene,  output_filename, strlen( output_filename ) );

    PanelTools::AlignLabels( source_scene, output_scene );

    // Instance Lister
    if( !( instance_listbox = LISTBOX_CTL( panel_funcs->orig_struct, main_panel,
                                           "Instance List", 363, 15,
                                           InstanceListerNames, InstanceListerCount)) )

    x = CON_X( instance_listbox );
    y = CON_Y( instance_listbox );
    MOVE_CON( instance_listbox, x+5, y );

    // Set the Panel Size
    y = CON_Y( instance_listbox );
    h = CON_H( instance_listbox );
    PAN_SETH( panel_funcs->orig_struct, main_panel, y + h + 30 );

    w = CON_X( output_scene );
    x = CON_W( output_scene );
    PAN_SETW( panel_funcs->orig_struct, main_panel, x + w );

    // Set the Draw Functions
    panel_funcs->Set( main_panel, PAN_USERDRAW, SG_DrawMainPanel );

    return true;
  } catch( bool a ) {
    if( !a ) {
      message->Error("Error creating interface controls; aborting" );
      return false;
    }
  }

  return true;
}
Exemple #10
0
int get_user( UnwrapParams *uwp )
{
   static char *text[] = {
      "Draws polygons in the 2D coordinate system of the selected texture layer.",
      NULL
   };
   static char *fgopt[] = {
      "Use Color",
      "Invert Background",
      "Brighten",
      "Darken",
      NULL
   };
   static char *bgopt[] = {
      "Use Color",
      "Copy Image Map",
      NULL
   };

   LWPanControlDesc desc;
   LWValue
      ival    = { LWT_INTEGER },
      sval    = { LWT_STRING },
      ivecval = { LWT_VINT };
   LWPanelID panel;
   LWControl *ctl[ 10 ], *bdr[ 2 ];
   Node *root;
   int i, x, y, w, ph, ok;


   root = make_list( panf->globalFun );
   if ( !root ) return 0;

   if( !( panel = PAN_CREATE( panf, "Unwrap" ))) {
      free_tree( root, 1 );
      return 0;
   }

   if ( !uwp->filename[ 0 ] ) {
      strcpy( uwp->filename, "unwrapped" );
      filename_ext( uwp->saver, uwp->filename );
      uwp->bgcolor[ 0 ] = uwp->bgcolor[ 1 ] = uwp->bgcolor[ 2 ] = 255;
   }

   TEXT_CTL( panf, panel, "", text );

   ctl[ 0 ] = TREE_CTL( panf, panel, "Texture Layer", 200, 200, tree_info,
      tree_count, tree_child );

   ph = PAN_GETH( panf, panel );
   ph -= CON_X( ctl[ 0 ] );
   ph -= CON_H( ctl[ 0 ] );

   ctl[ 1 ] = SAVE_CTL( panf, panel, "Save As", 40 );
   ctl[ 2 ] = CUSTPOPUP_CTL( panf, panel, "", 150, sname, scount );
   ctl[ 3 ] = INT_CTL( panf, panel, "Width" );
   ctl[ 4 ] = INT_CTL( panf, panel, "Height" );
   ctl[ 5 ] = BUTTON_CTL( panf, panel, "From Image Map" );
   ctl[ 6 ] = WPOPUP_CTL( panf, panel, "Edges", fgopt, 150 );
   ctl[ 7 ] = MINIRGB_CTL( panf, panel, "" );
   ctl[ 8 ] = WPOPUP_CTL( panf, panel, "Background", bgopt, 150 );
   ctl[ 9 ] = MINIRGB_CTL( panf, panel, "" );

   w = CON_W( ctl[ 1 ] );
   w -= CON_LW( ctl[ 1 ] );

   bdr[ 0 ] = BORDER_CTL( panf, panel, "", w, 2 );
   bdr[ 1 ] = BORDER_CTL( panf, panel, "", w, 2 );

   x = CON_X( ctl[ 0 ] );
   x += CON_W( ctl[ 0 ] );
   x += CON_LW( ctl[ 8 ] ) + 8;
   y = CON_Y( ctl[ 0 ] );

   w = CON_LW( ctl[ 1 ] );
   MOVE_CON( ctl[ 1 ], x - w, y );

   w = CON_LW( ctl[ 2 ] );
   y += CON_HOTH( ctl[ 1 ] ) + 4;
   MOVE_CON( ctl[ 2 ], x - w, y );

   y += CON_HOTH( ctl[ 2 ] ) + 6;
   MOVE_CON( bdr[ 0 ], x, y );

   w = CON_LW( ctl[ 3 ] );
   y += 6;
   MOVE_CON( ctl[ 3 ], x - w, y );

   w = CON_X( ctl[ 3 ] );
   w += CON_W( ctl[ 3 ] );
   MOVE_CON( ctl[ 5 ], w + 16, y );

   w = CON_LW( ctl[ 4 ] );
   y += CON_HOTH( ctl[ 3 ] ) + 4;
   MOVE_CON( ctl[ 4 ], x - w, y );

   y += CON_HOTH( ctl[ 2 ] ) + 6;
   MOVE_CON( bdr[ 1 ], x, y );

   y += 6;
   for ( i = 6; i <= 9; i++ ) {
      w = CON_LW( ctl[ i ] );
      MOVE_CON( ctl[ i ], x - w, y );
      y += CON_HOTH( ctl[ i ] ) + 4;
   }

   y = CON_Y( ctl[ 9 ] );
   y += CON_H( ctl[ 9 ] );
   PAN_SETH( panf, panel, y + ph );

   SET_STR( ctl[ 1 ], uwp->filename, sizeof( uwp->filename ));
   SET_INT( ctl[ 2 ], uwp->saver );
   SET_INT( ctl[ 3 ], uwp->width );
   SET_INT( ctl[ 4 ], uwp->height );
   SET_INT( ctl[ 6 ], uwp->fgoptions );
   SET_INT( ctl[ 8 ], uwp->bgoptions );
   SETV_IVEC( ctl[ 7 ], uwp->fgcolor );
   SETV_IVEC( ctl[ 9 ], uwp->bgcolor );

   CON_SETEVENT( ctl[ 0 ], tree_event, root );
   CON_SETEVENT( ctl[ 2 ], saver_event, ctl[ 1 ] );
   CON_SETEVENT( ctl[ 5 ], sizebtn_event, ctl );

   ok = panf->open( panel, PANF_BLOCKING | PANF_CANCEL );

   if ( ok ) {
      GET_STR( ctl[ 1 ], uwp->filename, sizeof( uwp->filename ));
      GET_INT( ctl[ 2 ], uwp->saver );
      GET_INT( ctl[ 3 ], uwp->width );
      GET_INT( ctl[ 4 ], uwp->height );
      GET_INT( ctl[ 6 ], uwp->fgoptions );
      GET_INT( ctl[ 8 ], uwp->bgoptions );
      GETV_IVEC( ctl[ 7 ], uwp->fgcolor );
      GETV_IVEC( ctl[ 9 ], uwp->bgcolor );

      ctl[ 0 ]->get( ctl[ 0 ], CTL_VALUE, &ival );
      if ( !getsel_tree( uwp, ( Node * ) ival.ptr.ptr )) {
         msgf->error( "No texture layer selected", NULL );
         ok = 0;
      }
   }

   PAN_KILL( panf, panel );

   free_tree( root, 1 );
   return ok;
}
Exemple #11
0
static void ctl_create( void )
{
   static char *labatype[] = { "Point", "Sphere", "Dodec", NULL };
   static char *labbtype[] = { "Line", "Cylinder", NULL };
   static char *labradii[] = { "Radii", NULL };
   int x, y, w, h, ph, i;


   /* create a control */

   ctl[ 0 ] = STR_CTL( panf, panel, "Sequence", 40 );

   /* find out how much vertical space the panel wants for drawing its
      own decorations, and get some other panel metrics */

   ph = PAN_GETH( panf, panel ) - CON_H( ctl[ 0 ] );
   dmet = panf->drawFuncs->dispMetrics();

   /* create the rest of the controls */

   ctl[  1 ] = WPOPUP_CTL( panf, panel, "Atoms", labatype, 100 );
   ctl[  2 ] = INT_CTL( panf, panel, "Sides" );
   ctl[  3 ] = INT_CTL( panf, panel, "Segments" );
   ctl[  4 ] = TEXT_CTL( panf, panel, "", labradii );
   ctl[  5 ] = FLOAT_CTL( panf, panel, "Carbon" );
   ctl[  6 ] = FLOAT_CTL( panf, panel, "Hydrogen" );
   ctl[  7 ] = FLOAT_CTL( panf, panel, "Nitrogen" );
   ctl[  8 ] = FLOAT_CTL( panf, panel, "Oxygen" );
   ctl[  9 ] = FLOAT_CTL( panf, panel, "Phosphorus" );
   ctl[ 10 ] = WPOPUP_CTL( panf, panel, "Bonds", labbtype, 100 );
   ctl[ 11 ] = INT_CTL( panf, panel, "Sides" );
   ctl[ 12 ] = INT_CTL( panf, panel, "Segments" );
   ctl[ 13 ] = FLOAT_CTL( panf, panel, "Radius" );
   ctl[ 14 ] = BOOL_CTL( panf, panel, "Base Plates" );

   w = 2 * panf->drawFuncs->textWidth( panel, "Polygons:" ) + 16;
   ctl[ 15 ] = CANVAS_CTL( panf, panel, "", w, 3 * dmet->textHeight );

   /* position all of the controls */

   x = CON_X( ctl[ 0 ] );
   x += CON_W( ctl[ 1 ] );
   h = CON_HOTH( ctl[ 1 ] ) + 4;

   w = CON_W( ctl[ 1 ] );
   y = CON_Y( ctl[ 0 ] ) + 3 * h / 2;
   MOVE_CON( ctl[ 1 ], x - w, y );

   w = CON_W( ctl[ 2 ] );
   MOVE_CON( ctl[ 2 ], x - w, y + 3 * h / 2 );

   w = CON_W( ctl[ 3 ] );
   y = CON_Y( ctl[ 2 ] );
   MOVE_CON( ctl[ 3 ], x - w, y + h );

   w = CON_W( ctl[ 4 ] );
   y = CON_Y( ctl[ 3 ] );
   MOVE_CON( ctl[ 4 ], ( x - w ) / 2, y + 3 * h / 2 );

   for ( i = 5; i < 10; i++ ) {
      w = CON_W( ctl[ i ] );
      y = CON_Y( ctl[ i - 1 ] );
      MOVE_CON( ctl[ i ], x - w, y + h );
   }

   x = x * 2 + 10;
   w = CON_W( ctl[ 10 ] );
   y = CON_Y( ctl[ 1 ] );
   MOVE_CON( ctl[ 10 ], x - w, y );

   w = CON_W( ctl[ 11 ] );
   y = CON_Y( ctl[ 10 ] );
   MOVE_CON( ctl[ 11 ], x - w, y + 3 * h / 2 );

   w = CON_W( ctl[ 12 ] );
   y = CON_Y( ctl[ 11 ] );
   MOVE_CON( ctl[ 12 ], x - w, y + h );

   w = CON_W( ctl[ 13 ] );
   y = CON_Y( ctl[ 12 ] );
   MOVE_CON( ctl[ 13 ], x - w, y + 3 * h / 2 );

   w = CON_W( ctl[ 14 ] );
   y = CON_Y( ctl[ 13 ] );
   MOVE_CON( ctl[ 14 ], x - w, y + 3 * h / 2 );

   w = CON_W( ctl[ 15 ] );
   y = CON_Y( ctl[ 14 ] );
   MOVE_CON( ctl[ 15 ], x - w, y + 2 * h );

   /* now that we know how much room the controls will take up, set the
      height of the panel */

   h = CON_Y( ctl[ 9 ] );
   h += CON_HOTH( ctl[ 9 ] );
   PAN_SETH( panf, panel, h + ph - 6 );

   /* initialize the controls */

   ctl_set();

   /* set the event handlers and user data */

   for ( i = 0; i < 15; i++ )
      CON_SETEVENT( ctl[ i ], ctl_event, NULL );

   ival.ptr.ptr = ctl_draw;
   ctl[ 15 ]->set( ctl[ 15 ], CTL_USERDRAW, &ival );
}
Exemple #12
0
// MakeOptionControls():
bool FreeKeyInterface::MakeOptionControls() {
  try {
    int x, y;

    // Undo Levels
    if( !( opt_undo_levels = MINISLIDER_CTL( panel_funcs->orig_struct, main_panel,
                                             "Undo Levels", 30, 0, 128 ) ) )
      throw false;

    // Fractional Keyframes
    if( !( opt_fractional_frames = BOOL_CTL( panel_funcs->orig_struct, main_panel,
                                             "Allow Fractional Frames" ) ) )
      throw false;

    // Item List Draw Style
    if( !( opt_draw_style = WPOPUP_CTL( panel_funcs->orig_struct, main_panel,
                                        "Item List Draw Style", opt_draw_style_text, 150 ) ) )
      throw false;

    SET_INT( opt_draw_style, fk->GetDrawStyle() );

    // Use OpenGL Item List
    if( !( opt_use_opengl_item_list = BOOL_CTL( panel_funcs->orig_struct, main_panel,
                                                "Use OpenGL Item List" ) ) )
      throw false;

    SET_INT( opt_use_opengl_item_list, (int)fk->GetUseOpenGLItemList() );

    // Use OpenGL Legacy Alignment
    if( !( opt_use_opengl_legacy = BOOL_CTL( panel_funcs->orig_struct, main_panel,
                                             "Use Legacy OpenGL Icon Alignment" ) ) )
      throw false;

    SET_INT( opt_use_opengl_legacy, (int)GLTLWIcons::GetLegacyOffset() );

    PanelTools::PutUnder( tool_options_tabs, opt_undo_levels );
    x = CON_X( opt_undo_levels );
    y = CON_Y( opt_undo_levels );
    MOVE_CON( opt_undo_levels, x, y+4 );

    PanelTools::PutOnLineWith( opt_undo_levels, opt_fractional_frames, 25 );
    PanelTools::PutOnLineWith( opt_fractional_frames, opt_draw_style,  25 );

    PanelTools::PutUnder( opt_fractional_frames, opt_use_opengl_item_list );
    x = CON_X( opt_fractional_frames );
    y = CON_Y( opt_use_opengl_item_list );
    MOVE_CON( opt_use_opengl_item_list, x, y );

    PanelTools::PutUnder( opt_use_opengl_item_list, opt_use_opengl_legacy );
    y = CON_Y( opt_use_opengl_legacy );
    MOVE_CON( opt_use_opengl_legacy, x, y );

    // Event Handler Functions
    CON_SETEVENT( opt_draw_style,           OnOptDrawStyle,         this );
    CON_SETEVENT( opt_use_opengl_item_list, OnOptUseOpenGLItemList, this );
    CON_SETEVENT( opt_use_opengl_legacy,    OnOptUseOpenGLLegacy,   this );

    return true;
  } catch( bool ) {
    return false;
  }

  return true;
}
Exemple #13
0
// MakeMainControls():
bool FreeKeyInterface::MakeMainControls() {
  try {
    int x, y, w;

    // Title Image (OpenGL)
    if( !( title_image = OPENGL_CTL( panel_funcs->orig_struct, main_panel,
                                     "", decoded_logo_small->GetWidth() - 25, decoded_logo_small->GetHeight() ) ) )
      throw false;

    MOVE_CON( title_image, -13, -4 );

    // File ItemSelection Conrols
    if( !( source_scene = FILE_CTL( panel_funcs->orig_struct, main_panel,
                                    "Source Scene", 91 ) ) )
      throw false;

    if( !( source_popup = POPDOWN_CTL( panel_funcs->orig_struct, main_panel,
                                       "Source Tools", source_popup_text ) ) )
      throw false;

    if( !( output_scene = FILE_CTL( panel_funcs->orig_struct, main_panel,
                                    "Output Scene", 91 ) ) )
      throw false;

    if( !( output_popup = POPDOWN_CTL( panel_funcs->orig_struct, main_panel,
                                       " Output Tools", output_popup_text ) ) )
      throw false;

//    x = CON_X( source_scene );
//    y = CON_Y( source_scene );
//    MOVE_CON( source_scene, x, y + 35 );

    PanelTools::PutUnder( source_scene, source_scene, -11 );
    PanelTools::AlignLabels( source_scene, output_scene, 5 );
    PanelTools::PutOnLineWith( source_scene, source_popup, -10 );
    PanelTools::PutOnLineWith( output_scene, output_popup, -10 );

    // Default Settings for String/File and Popup Controls
    SET_STR( source_scene,  (char *)fk->GetSource(),   strlen( fk->GetSource()   ) );
    SET_STR( output_scene,  (char *)fk->GetOutput(),   strlen( fk->GetOutput()   ) );

    const int list_x_offset = 130;

    // List Controls
    if( !( list_fold = WBUTTON_CTL( panel_funcs->orig_struct, main_panel,
                                    "Fold", 50 ) ) )
      throw false;

    if( !( list_unfold = WBUTTON_CTL( panel_funcs->orig_struct, main_panel,
                                      "Unfold", 50 ) ) )
      throw false;

    if( !( select_count = INTRO_CTL( panel_funcs->orig_struct, main_panel,
                                     "" ) ) )
      throw false;

    // Display Controls
    if( !( display_key_mode = WPOPUP_CTL( panel_funcs->orig_struct, main_panel,
                                          "Key Mode", display_key_mode_text, 130 ) ) )
      throw false;

    if( !( display_item_mode = WPOPUP_CTL( panel_funcs->orig_struct, main_panel,
                                          "Item List", display_mode_text, 130 ) ) )
      throw false;

    SET_INT( display_key_mode,  fk->GetKeyDisplayMode()  );
    SET_INT( display_item_mode, fk->GetItemDisplayMode() );

    PanelTools::PutUnder( output_scene, list_fold );
    PanelTools::PutUnder( list_fold, list_fold );

    x = CON_X( list_fold );
    y = CON_Y( list_fold );
    MOVE_CON( list_fold, x + 10 + list_x_offset, y-6 );
    PanelTools::PutOnLineWith( list_fold, list_unfold, -7 );
    PanelTools::PutOnLineWith( list_unfold, select_count, 15);
    PanelTools::PutOnLineWith( select_count, display_key_mode, 15 );
    PanelTools::PutOnLineWith( display_key_mode, display_item_mode );

    // Time Controls
    if( !( item_first_frame = FLOAT_CTL( panel_funcs->orig_struct, main_panel,
                                         "Low Frame" ) ) )
      throw false;

    if( !( item_current_frame = FLOAT_CTL( panel_funcs->orig_struct, main_panel,
                                           "Current Frame" ) ) )
      throw false;

    if( !( item_jump_to_frame = WBUTTON_CTL( panel_funcs->orig_struct, main_panel, "", 20 ) ) )
      throw false;

    if( !( item_last_frame = FLOAT_CTL( panel_funcs->orig_struct, main_panel,
                                         "High Frame" ) ) )
      throw false;

    if( !( item_range_presets = POPDOWN_CTL( panel_funcs->orig_struct, main_panel,
                                             " Ranges", item_range_preset_text ) ) )
      throw false;

    SET_FLOAT( item_current_frame, fk->GetCurrentTime() * default_fps );
    SET_FLOAT( item_first_frame,   fk->GetDisplayMin()  * default_fps );
    SET_FLOAT( item_last_frame,    fk->GetDisplayMax()  * default_fps );

    PanelTools::PutUnder( list_fold, item_first_frame );
    x = CON_X( item_first_frame );
    y = CON_Y( item_first_frame );
    MOVE_CON( item_first_frame, x + list_x_offset + 40, y );

    PanelTools::PutOnLineWith( item_first_frame, item_current_frame,   20 );
    PanelTools::PutOnLineWith( item_current_frame, item_jump_to_frame, -5 );
    PanelTools::PutOnLineWith( item_jump_to_frame, item_last_frame,    20 );
    PanelTools::PutOnLineWith( item_last_frame, item_range_presets,    -2 );

    // Item List
    if( !( item_list = CANVAS_CTL( panel_funcs->orig_struct, main_panel,
                                   "", 625, 263 ) ) )
      throw false;

    if( !( opengl_item_list = OPENGL_CTL( panel_funcs->orig_struct, main_panel,
                                          "", 625, 263 ) ) )
      throw false;

    if( !( item_scroll = VSLIDER_CTL( panel_funcs->orig_struct, main_panel,
                                      "", 259, 0, 0 ) ) )
      throw false;

    PanelTools::PutUnder( item_first_frame, item_list );

    x = CON_X( item_list );
    y = CON_Y( item_list );
    MOVE_CON( item_list,        x + list_x_offset, y );
    MOVE_CON( opengl_item_list, x + list_x_offset, y );

    w = CON_W( item_list );
    MOVE_CON( item_scroll, x+w-18 + list_x_offset, y );

    UpdateItemListType( fk->GetUseOpenGLItemList() );

    // MultiSlider/Zoom
    if( !( item_zoom = PERCENT_CTL( panel_funcs->orig_struct, main_panel, "Zoom" ) ) )
      throw false;

    SET_FLOAT( item_zoom, fk->GetZoom() * 100.0 );

    if( !( item_multiscroll = DRAGAREA_CTL( panel_funcs->orig_struct, main_panel,
                                            "", 620 + list_x_offset - CON_W( item_zoom ) - 1, 16 ) ) )
      throw false;

    PanelTools::PutUnder( item_list, item_zoom );
    x = CON_X( item_zoom );
    y = CON_Y( item_zoom );
    MOVE_CON( item_zoom, x+8, y );

    PanelTools::PutOnLineWith( item_zoom, item_multiscroll );
    x = CON_X( item_multiscroll );
    y = CON_Y( item_multiscroll );
    MOVE_CON( item_multiscroll, x, y+1 );

    // Tabs
    if( !( tool_options_tabs = TABCHOICE_CTL( panel_funcs->orig_struct, main_panel,
                                             "", tool_option_tab_text ) ) )
      throw false;

    PanelTools::PutUnder( item_multiscroll, tool_options_tabs );
    PanelTools::PutUnder( tool_options_tabs, tool_options_tabs );

    // Group List
    if( !( group_list = CUSTPOPUP_CTL( panel_funcs->orig_struct, main_panel,
                                       "Group", 200,
                                       GroupNames, GroupCount ) ) )
      throw false;

    PanelTools::PutOnLineWith( tool_options_tabs, group_list, 12 );
    x = CON_X( group_list );
    y = CON_Y( group_list );
    MOVE_CON( group_list, x, y-5 );

    // About FreeKey button
    if( !( about = WBUTTON_CTL( panel_funcs->orig_struct, main_panel,
                            "About", 63 ) ) )
      throw false;

    // F1 (Keyboard Help) Button
    if( !( f1 = WBUTTON_CTL( panel_funcs->orig_struct, main_panel,
                             "F1", 30 ) ) )
      throw false;

    PanelTools::PutOnLineWith( group_list, about );
    PanelTools::PutOnLineWith( about, f1 );

    // Range Controls
    if( !( range_low = MINISLIDER_CTL( panel_funcs->orig_struct, main_panel,
                                       "Range   Low", 30, 0, 1000000 ) ) )
      throw false;

    if( !( range_high = MINISLIDER_CTL( panel_funcs->orig_struct, main_panel,
                                        "High", 30, 0, 1000000 ) ) )
      throw false;
    SET_INT( range_high, 1000000 );

    PanelTools::PutUnder( tool_options_tabs, range_low );
    PanelTools::PutUnder( range_low, range_low );
    PanelTools::PutUnder( range_low, range_low );
    PanelTools::PutUnder( range_low, range_low );
    PanelTools::PutUnder( range_low, range_low );
    PanelTools::PutOnLineWith( range_low, range_high );

    // Remove Mode
    if( !( remove_mode = WPOPUP_CTL( panel_funcs->orig_struct, main_panel,
                                     "Remove Mode", remove_mode_text, 250 ) ) )
      throw false;
    PanelTools::PutOnLineWith( range_high, remove_mode, 20 );
    y = CON_Y( remove_mode );
    MOVE_CON( remove_mode, 325, y );

    // Step
    if( !( step_amount = MINISLIDER_CTL( panel_funcs->orig_struct, main_panel,
                                         "Step Amount", 30, 0, 32767 ) ) )
      throw false;

    if( !( step_mode = WPOPUP_CTL( panel_funcs->orig_struct, main_panel,
                                   "Step Mode", step_mode_text, 250 ) ) )
      throw false;

    PanelTools::PutUnder( range_low, step_amount );
    PanelTools::PutOnLineWith( step_amount, step_mode );

    // Delta
    if( !( delta_amount = MINISLIDER_CTL( panel_funcs->orig_struct, main_panel,
                                          "Delta Amount", 30, -32768, 32767 ) ) )
      throw false;

    if( !( delta_mode = BOOL_CTL( panel_funcs->orig_struct, main_panel,
                                  "Enable Time Delta" ) ) )
      throw false;

    PanelTools::PutUnder( step_amount, delta_amount );
    PanelTools::PutOnLineWith( delta_amount, delta_mode );

    // Direction
    if( !( direction_mode = WPOPUP_CTL( panel_funcs->orig_struct, main_panel,
                                   "Direction", direction_mode_text, 250 ) ) )
      throw false;

    PanelTools::PutOnLineWith( delta_amount, direction_mode );

    // Scale
    if( !( scale_amount = FLOAT_CTL( panel_funcs->orig_struct, main_panel,
                                          "Scale Factor" ) ) )
      throw false;

    if( !( scale_mode = BOOL_CTL( panel_funcs->orig_struct, main_panel,
                                  "Enable Scale Keys" ) ) )
      throw false;

    PanelTools::PutUnder( delta_amount, scale_amount );
    PanelTools::PutOnLineWith( scale_amount, scale_mode );

    // Fix Some Alignments
    LWControl *align1[] = { range_low, step_amount, delta_amount, scale_amount, NULL };
    PanelTools::AlignLabels( align1 );
    PanelTools::PutOnLineWith( range_low, range_high );

    LWControl *align2[] = { remove_mode, step_mode, direction_mode, NULL };
    PanelTools::AlignLabels( align2 );

    PanelTools::PutOnLineWith( delta_amount, delta_mode );
    x = CON_X( delta_mode );
    y = CON_Y( scale_mode );
    MOVE_CON( scale_mode, x, y );

    // Status Line
    if( !( status_line = CANVAS_CTL( panel_funcs->orig_struct, main_panel,                     // Compare Mode pop-up
                                     "", 600, 15 ) ) )
      throw false;
  
    PanelTools::PutUnder( scale_amount, status_line );
    PanelTools::PutUnder( status_line, status_line );

    // FreeKey-ify button
    if( !( freekey = WBUTTON_CTL( panel_funcs->orig_struct, main_panel,
                                  "FreeKey-ify!", 150 ) ) )
      throw false;
    PanelTools::PutOnLineWith( status_line, freekey, -8 );

    // Right-Align the F1 Button
    int x2 = CON_X( item_scroll );
    int w2 = CON_W( item_scroll );
    y = CON_Y( f1 );
    w = CON_W( f1 );
    MOVE_CON( f1, x2+w2-w, y );

    // Move the About Button just to the left of the F1 Button
    y = CON_Y( about );
    w = CON_W( about );
    x = CON_X( f1 );
    MOVE_CON( about, x-w+5, y );

    PAN_SETW( panel_funcs->orig_struct, main_panel, decoded_logo_small->GetWidth() - 30 );

    // Envent Handler Functions
    CON_SETEVENT( about,                   OnAbout,              this );
    CON_SETEVENT( source_scene,            OnSourceFile,         this );
    CON_SETEVENT( output_scene,            OnOutputFile,         this );
    CON_SETEVENT( source_popup,            OnSourcePopup,        this );
    CON_SETEVENT( output_popup,            OnOutputPopup,        this );
    CON_SETEVENT( item_first_frame,        OnFirstFrame,         this );
    CON_SETEVENT( item_last_frame,         OnLastFrame,          this );
    CON_SETEVENT( item_range_presets,      OnItemRangePresets,   this );
    CON_SETEVENT( item_scroll,             OnItemScroll,         this );
    CON_SETEVENT( item_multiscroll,        OnItemMultiScroll2,   this );
    CON_SETEVENT( item_zoom,               OnItemZoom,           this );
    CON_SETEVENT( list_fold,               OnFoldList,           this );
    CON_SETEVENT( list_unfold,             OnUnFoldList,         this );
    CON_SETEVENT( display_key_mode,        OnKeyFrameMode,       this );
    CON_SETEVENT( display_item_mode,       OnDisplayMode,        this );
    CON_SETEVENT( tool_options_tabs,       OnToolOptionsTabs,    this );
    CON_SETEVENT( group_list,              OnGroupList,          this );

    CON_SETEVENT( range_low,               OnRangeLow,           this );
    CON_SETEVENT( range_high,              OnRangeHigh,          this );
    CON_SETEVENT( remove_mode,             OnRemoveMode,         this );
    CON_SETEVENT( step_amount,             OnStepAmount,         this );
    CON_SETEVENT( step_mode,               OnStepMode,           this );
    CON_SETEVENT( delta_amount,            OnDeltaAmount,        this );
    CON_SETEVENT( delta_mode,              OnDeltaMode,          this );
    CON_SETEVENT( scale_amount,            OnScaleAmount,        this );
    CON_SETEVENT( scale_mode,              OnScaleMode,          this );
    CON_SETEVENT( direction_mode,          OnDirectionMode,      this );

    CON_SETEVENT( f1,                      OnF1,                 this );
    CON_SETEVENT( freekey,                 OnFreeKey,            this );

    CON_SETEVENT( item_list,               OnItemList,           this );
//    CON_SETEVENT( opengl_item_list,        OnItemList,           this );

    // Set the Draw Functions
    ival.intv.value = (int)&DrawItemJumpToFrame;
    (*item_jump_to_frame->set)( item_jump_to_frame, CTL_USERDRAW, &ival );

    ival.intv.value = (int)&DrawItemListbox;
    (*item_list->set)( item_list, CTL_USERDRAW, &ival );

    // For some inexplicable reason, the draw function is an event for OpenGL controls.  Go fig.
//    ival.intv.value = (int)&DrawOpenGLItemListbox;
//    (*opengl_item_list->set)( opengl_item_list, CTL_USERDRAW, &ival );
    CON_SETEVENT( opengl_item_list, DrawOpenGLItemListbox, this );

    ival.intv.value = (int)&DrawItemMultiScroll;
    (*item_multiscroll->set)( item_multiscroll, CTL_USERDRAW, &ival );

    ival.intv.value = (int)&DrawStatusLine;
    (*status_line->set)( status_line, CTL_USERDRAW, &ival );

    CON_SETEVENT( title_image, DrawTitleImage, this );

    return true;
  } catch( bool ) {
    return false;
  }

  return true;
}
Exemple #14
0
// OpenUI():
//  Opens the user interface.  Returns after the panel has been closed.
bool ReplaceObjects_Interface::OpenUI() {
  // Destroy the panel if it hasn't been destroyed yet
  if( panel != NULL ) {
    (*panel_funcs->destroy)( panel );
    panel = NULL;
  }

  char title_string[256];
  sprintf( title_string, "ReplaceObjects -- %c2001 Joe Angell, TM Productions", 169 );
  panel = (*panel_funcs->create)( title_string, panel_funcs );
  if( !panel ) {                    // Make sure the panel was created
    (*message->error)("Error creating main panel, aborting", NULL );
    return false;
  }

  // Limit To Pop-Up
  limit_to_popup = WPOPUP_CTL( panel_funcs, panel, "Limit To",
                               limit_to_popup_strings, 110 );

  // Sort By Pop-Up
  sort_by_popup = WPOPUP_CTL( panel_funcs, panel, "Sort By",
                              sort_by_popup_strings, 110 );
  PanelTools::PutOnLineWith( limit_to_popup, sort_by_popup, 10 );

  // Match
  match_toggle = BOOL_CTL( panel_funcs, panel, "Match Name" );
  match_string = STR_CTL(  panel_funcs, panel, "Name Contains", 41 );
  PanelTools::PutOnLineWith( match_toggle, match_string, 10 );

  // List
  list = MULTILIST_CTL( panel_funcs, panel, "Swap Objects",
                        300, 20, ListNames, ListCount, ListColumnWidths );
  PanelTools::PutUnder( match_toggle, list, 20 );

  // Add
  add = WBUTTON_CTL( panel_funcs, panel, "Add", 60 );
  PanelTools::PutOnLineWith( list, add, 3);

  // Clone
  clone = WBUTTON_CTL( panel_funcs, panel, "Clone", 60 );
  PanelTools::AlignLabels( add, clone );

  // Remove
  remove = WBUTTON_CTL( panel_funcs, panel, "Remove", 60 );
  PanelTools::AlignLabels( clone, remove );

  // Clear All
  clear_all  = WBUTTON_CTL( panel_funcs, panel, "Clear All", 60 );
  PanelTools::AlignLabels( remove, clear_all );
  PanelTools::PutUnder( clear_all, clear_all );

  // About
  about = WBUTTON_CTL( panel_funcs, panel, "About", 60 );
  PanelTools::PutOnLineWith( sort_by_popup, about );

  // Load
  load = LOADBUTTON_CTL( panel_funcs, panel, "Load", 60 );
  PanelTools::PutOnLineWith( sort_by_popup, about );

  // Save
  save = SAVEBUTTON_CTL( panel_funcs, panel, "Save", 60 );
  PanelTools::PutOnLineWith( sort_by_popup, about );

  // Path
  path = FILE_CTL( panel_funcs, panel, "Object Path", 59 );
  PanelTools::PutUnder( list, path, 18 );

  // Weight
  weight = FLOAT_CTL( panel_funcs, panel, "Weight" );
  PanelTools::AlignLabels( path, weight );

  // Enable
  enable = BOOL_CTL( panel_funcs, panel, "Enable" );
  PanelTools::PutOnLineWith( weight, enable );

  // Store Original Names
  store_original_name = BOOL_CTL( panel_funcs, panel, "Store Original Object Name As Tag" );
  SET_INT( store_original_name, store_original_name_value );
  PanelTools::AlignLabels( weight, store_original_name, 18 );

  int x  = CON_X( add );
  int y  = CON_Y( list );
  int h  = CON_H( list );
  int h2 = CON_H( about );
  MOVE_CON( about, x, (y + h) - h2 );
  MOVE_CON( save,  x, (y + h) - (h2 * 3) + 10 );
  MOVE_CON( load,  x, (y + h) - (h2 * 4) + 15 );

  // Default Values
  SET_INT( list, -1 );
  HandleList( list, NULL );

  // Event Handlers
  CON_SETEVENT( list,          HandleList,        NULL );
  CON_SETEVENT( about,         HandleAbout,       NULL );

  CON_SETEVENT( sort_by_popup, HandleSortBy,      NULL );
  CON_SETEVENT( match_toggle,  HandleMatchToggle, NULL );

  CON_SETEVENT( add,           HandleAdd,         NULL );
  CON_SETEVENT( clone,         HandleClone,       NULL );
  CON_SETEVENT( remove,        HandleRemove,      NULL );
  CON_SETEVENT( clear_all,     HandleClearAll,    NULL );

  CON_SETEVENT( load,          HandleLoad,        NULL );
  CON_SETEVENT( save,          HandleSave,        NULL );

  CON_SETEVENT( path,          HandlePath,        NULL );
  CON_SETEVENT( weight,        HandleWeight,      NULL );
  CON_SETEVENT( enable,        HandleEnable,      NULL );

  // Panel-Level Callbacks
  (*panel_funcs->set)( panel, PAN_USERDRAW, DrawPanel );

  // Get a copy of the swaps
  swaps.Flush();
  ReplaceObjects_SwapObject *new_swap;
  for( unsigned long i=0; i < old_swaps.NumElements(); i++ ) {
    new_swap = new ReplaceObjects_SwapObject;
    *new_swap = *old_swaps[i];
    swaps.Add( new_swap );
  }

  HandleMatchToggle( match_toggle, NULL );

  // Open the Panel
  int retval = (*panel_funcs->open)( panel, PANF_BLOCKING | PANF_CANCEL | PANF_PASSALLKEYS );
  if( retval > 0 ) {
    do_process = true;
    GET_INT( store_original_name, store_original_name_value );

    old_swaps.Flush();
    ReplaceObjects_SwapObject *new_swap;
    for( unsigned long i=0; i < swaps.NumElements(); i++ ) {
      new_swap = new ReplaceObjects_SwapObject;
      *new_swap = *swaps[i];
      old_swaps.Add( new_swap );
    }
  }

  return do_process;
}
Exemple #15
0
static int print_ui( char *outname, int *range, int *mode, int *cols,
   char *comment )
{
   char *rlist[] = { "Current Page", "Entire File", NULL };
   char *mlist[] = { "Write", "Append", NULL };
   char *tlist[] = { " ", NULL };
   LWPanelID panel;
   LWControl *ctl[ 8 ];
   int i, x, y, dy, ok;

   if( !( panel = PAN_CREATE( panf, "Print to File" )))
      return 0;

   ctl[ 0 ] = FILE_CTL( panf, panel, "File", 40 );
   ctl[ 1 ] = HCHOICE_CTL( panf, panel, "Range", rlist );
   ctl[ 2 ] = HCHOICE_CTL( panf, panel, "Mode", mlist );
   ctl[ 3 ] = TEXT_CTL( panf, panel, "Columns", tlist );
   ctl[ 4 ] = BOOLBUTTON_CTL( panf, panel, "Position" );
   ctl[ 5 ] = BOOLBUTTON_CTL( panf, panel, "Buffer" );
   ctl[ 6 ] = BOOLBUTTON_CTL( panf, panel, "Printable" );
   ctl[ 7 ] = STR_CTL( panf, panel, "Comment", 40 );

   for ( i = 0; i < 4; i++ ) {
      ival.intv.value = 100 - CON_LW( ctl[ i ] );
      ctl[ i ]->set( ctl[ i ], CTL_X, &ival );
   }

   x = CON_HOTX( ctl[ 2 ] );
   y = CON_Y( ctl[ 2 ] );
   dy = y - CON_Y( ctl[ 1 ] );
   y += dy;

   MOVE_CON( ctl[ 4 ], x, y );
   x += CON_W( ctl[ 4 ] );
   MOVE_CON( ctl[ 5 ], x, y );
   x += CON_W( ctl[ 5 ] );
   MOVE_CON( ctl[ 6 ], x, y );
   x = 100 - CON_LW( ctl[ 7 ] );
   y += dy;
   MOVE_CON( ctl[ 7 ], x, y );

   PAN_SETH( panf, panel, y + dy );

   SET_STR( ctl[ 0 ], outname, 256 );
   SET_INT( ctl[ 1 ], *range );
   SET_INT( ctl[ 2 ], *mode );
   SET_INT( ctl[ 4 ], ( *cols & 1 ));
   SET_INT( ctl[ 5 ], ( *cols & 2 ));
   SET_INT( ctl[ 6 ], ( *cols & 4 ));
   SET_STR( ctl[ 7 ], comment, 256 );

   ok = panf->open( panel, PANF_BLOCKING | PANF_CANCEL );

   if ( ok ) {
      GET_STR( ctl[ 0 ], outname, 256 );
      GET_INT( ctl[ 1 ], *range );
      GET_INT( ctl[ 2 ], *mode );
      GET_INT( ctl[ 4 ], i );  if ( i ) *cols |= 1; else *cols &= ~1;
      GET_INT( ctl[ 5 ], i );  if ( i ) *cols |= 2; else *cols &= ~2;
      GET_INT( ctl[ 6 ], i );  if ( i ) *cols |= 4; else *cols &= ~4;
      GET_STR( ctl[ 7 ], comment, 256 );
   }

   PAN_KILL( panf, panel );

   return ok;
}
Exemple #16
0
static void create_controls( void )
{
   static char *labtype[] = { "Byte", "Word", "Long", "Float", "Double", NULL };
   static char *labbyte[] = { "Intel", "Motorola", NULL };
   static char *labjump[] = { "Absolute", "Forward", "Backward", NULL };
   static char *labsrch[] = { "Text", "Text + Hex", "Current", NULL };
   int x, y, ph;


   /* create a control */

   ctl[ 1 ] = STR_CTL( panf, panel, "", 58 );

   /* find out how much vertical space the panel wants for drawing its
      own decorations */

   ph = PAN_GETH( panf, panel ) - CON_H( ctl[ 1 ] );

   /* create the rest of the controls */

   ctl[  0 ] = CANVAS_CTL( panf, panel, "", 78 * TXWIDTH + DX * 2,
      NROWS * TXHEIGHT + DY * 2 );

   ctl[  2 ] = STRRO_CTL( panf, panel, "", 21 );
   ctl[  3 ] = WPOPUP_CTL( panf, panel, "", labtype, 76 );
   ctl[  4 ] = BOOL_CTL( panf, panel, "Unsigned" );
   ctl[  5 ] = WPOPUP_CTL( panf, panel, "", labbyte, 76 );
   ctl[  6 ] = MINISLIDER_CTL( panf, panel, "", 4, 1, 16 );
   ctl[  7 ] = STR_CTL( panf, panel, "Jump", 12 );
   ctl[  8 ] = WBUTTON_CTL( panf, panel, "Search", 56 );
   ctl[  9 ] = STRRO_CTL( panf, panel, "Mod", 4 );
   ctl[ 10 ] = VSLIDER_CTL( panf, panel, "", NROWS * TXHEIGHT + DY * 2, 0, 1000 );
   ctl[ 11 ] = STRRO_CTL( panf, panel, "", 12 );
   ctl[ 12 ] = WPOPUP_CTL( panf, panel, "", labjump, 80 );
   ctl[ 13 ] = STR_CTL( panf, panel, "", 24 );
   ctl[ 14 ] = WPOPUP_CTL( panf, panel, "", labsrch, 80 );
   ctl[ 15 ] = CANVAS_CTL( panf, panel, "", 32, 32 );
   ctl[ 16 ] = WBUTTON_CTL( panf, panel, "New", 40 );

   /* position all of the controls */

   x = CON_X( ctl[ 0 ] );
   y = CON_Y( ctl[ 0 ] );
   y += CON_H( ctl[ 2 ] );
   MOVE_CON( ctl[ 0 ], x, y + 2 );

   y = CON_Y( ctl[ 0 ] );
   MOVE_CON( ctl[ 10 ], 79 * TXWIDTH + 10, y + 1 );

   y = CON_Y( ctl[ 1 ] ) + 2;
   x = CON_X( ctl[ 0 ] );
   MOVE_CON( ctl[ 16 ], x + DX, y );

   x += CON_W( ctl[ 16 ] );
   MOVE_CON( ctl[ 1 ], x, y );

   x = CON_X( ctl[ 1 ] );
   x += CON_W( ctl[ 1 ] );
   MOVE_CON( ctl[ 2 ], x, y );

   x = CON_X( ctl[ 10 ] );
   x += CON_W( ctl[ 10 ] );
   MOVE_CON( ctl[ 15 ], x - 32, y );

   y += CON_H( ctl[ 1 ] ) - 2;
   x = CON_X( ctl[ 0 ] );
   MOVE_CON( ctl[ 11 ], x - 3, y );

   x += CON_W( ctl[ 11 ] );
   MOVE_CON( ctl[ 9 ], x, y );

   x = CON_X( ctl[ 9 ] );
   x += CON_W( ctl[ 9 ] );
   MOVE_CON( ctl[ 6 ], x, y );

   x = CON_X( ctl[ 6 ] );
   x += CON_W( ctl[ 6 ] );
   MOVE_CON( ctl[ 5 ], x, y );

   x = CON_X( ctl[ 5 ] );
   x += CON_W( ctl[ 5 ] );
   MOVE_CON( ctl[ 3 ], x - 6, y );

   x = CON_X( ctl[ 3 ] );
   x += CON_W( ctl[ 3 ] );
   MOVE_CON( ctl[ 4 ], x, y );

   y = CON_Y( ctl[ 0 ] );
   y += CON_H( ctl[ 0 ] );
   x = CON_X( ctl[ 0 ] );
   MOVE_CON( ctl[ 7 ], x + DX, y );

   x = CON_X( ctl[ 7 ] );
   x += CON_W( ctl[ 7 ] );
   MOVE_CON( ctl[ 12 ], x - 4, y );

   x = CON_X( ctl[ 12 ] );
   x += CON_W( ctl[ 12 ] );
   MOVE_CON( ctl[ 8 ], x + 18, y );

   x = CON_X( ctl[ 8 ] );
   x += CON_W( ctl[ 8 ] );
   MOVE_CON( ctl[ 13 ], x - 4, y );

   x = CON_X( ctl[ 13 ] );
   x += CON_W( ctl[ 13 ] );
   MOVE_CON( ctl[ 14 ], x - 4, y );

   /* now that we know how much room the controls will take up, set the
      height of the panel */

   y = CON_Y( ctl[ 8 ] );
   y += CON_H( ctl[ 8 ] );
   PAN_SETH( panf, panel, y + ph - 6 );

   /* initialize the controls */

   SET_INT( ctl[ 3 ], datatype );
   SET_INT( ctl[ 4 ], unsign );
   SET_INT( ctl[ 5 ], byteorder );
   SET_INT( ctl[ 6 ], linesize );
   SET_STR( ctl[ 7 ], "0", 2 );
   SET_STR( ctl[ 9 ], "0", 2 );
   SET_INT( ctl[ 10 ], 0 );
   SET_STR( ctl[ 11 ], "0", 2 );
   SET_INT( ctl[ 12 ], 0 );
   SET_INT( ctl[ 14 ], 0 );

   /* set the control event callbacks */

   CON_SETEVENT( ctl[  1 ], handle_file, NULL );
   CON_SETEVENT( ctl[  3 ], handle_datatype, NULL );
   CON_SETEVENT( ctl[  4 ], handle_unsigned, NULL );
   CON_SETEVENT( ctl[  5 ], handle_byteorder, NULL );
   CON_SETEVENT( ctl[  6 ], handle_rowsize, NULL );
   CON_SETEVENT( ctl[  7 ], handle_jump, NULL );
   CON_SETEVENT( ctl[  8 ], handle_search, NULL );
   CON_SETEVENT( ctl[ 10 ], handle_scroll, NULL );
   CON_SETEVENT( ctl[ 13 ], handle_search, NULL );
   CON_SETEVENT( ctl[ 16 ], handle_new, NULL );

   /* set the control drawing callbacks */

   ival.ptr.ptr = drawcb_text;
   ctl[ 0 ]->set( ctl[ 0 ], CTL_USERDRAW, &ival );
   ival.ptr.ptr = drawcb_icon;
   ctl[ 15 ]->set( ctl[ 15 ], CTL_USERDRAW, &ival );
}
Exemple #17
0
// MakeItemSelectionControls():
bool FreeKeyInterface::MakeItemSelectionControls() {
  try {
    int x, y;
    // ItemSelection Controls
    if( !( select_item_name = STR_CTL( panel_funcs->orig_struct, main_panel,
                                       "Match String", 65 ) ) )
      throw false;

    if( !( select_name_mode = WPOPUP_CTL( panel_funcs->orig_struct, main_panel,
                                          "Compare", selection_name_text, 100 ) ) )
      throw false;

    if( !( select_toggle = WPOPUP_CTL( panel_funcs->orig_struct, main_panel,
                                       "Mode", select_toggle_text, 83 ) ) )
      throw false;

    if( !( select_item_mode = WPOPUP_CTL( panel_funcs->orig_struct, main_panel,
                                          "", selection_mode_text, 257 ) ) )
      throw false;

    if( !( select_children_toggle = BOOL_CTL( panel_funcs->orig_struct, main_panel,
                                             "And Children" ) ) )
      throw false;

    if( !( apply_select_item_name = WBUTTON_CTL( panel_funcs->orig_struct, main_panel,
                                                 "Apply", 100 ) ) )
      throw false;

    SET_INT( select_item_mode, 1 );
    SET_INT( select_name_mode, 1 );
    SET_INT( select_children_toggle, 1 );
    SET_INT( select_toggle, 0 );

    PanelTools::PutUnder( tool_options_tabs, select_item_name );
    x = CON_X( select_item_name );
    y = CON_Y( select_item_name );
    MOVE_CON( select_item_name, x, y+4 );

    PanelTools::PutOnLineWith( select_item_name, select_name_mode, -2 );
    PanelTools::AlignLabels( select_item_name, select_toggle );
    PanelTools::PutOnLineWith( select_toggle, select_item_mode );
    PanelTools::PutOnLineWith( select_item_mode, select_children_toggle );
    PanelTools::PutOnLineWith( select_children_toggle, apply_select_item_name );

        x  = CON_X( apply_select_item_name );
    int w  = CON_W( apply_select_item_name );
    int x2 = CON_X( item_scroll );
    int w2 = CON_W( item_scroll );

    int y2 = CON_HOTY( select_name_mode );
        y  = CON_HOTY( apply_select_item_name );
    int h  = CON_HOTH( apply_select_item_name );

    // Item Selection Info
    if( !( select_info_area = AREA_CTL( panel_funcs->orig_struct, main_panel,
                                        "", (x2+w2) - (x+w) - 20, (y+h) - y2 ) ) )
      throw false;

    PanelTools::PutOnLineWith( select_name_mode, select_info_area );

    // Event Handler Functions
    CON_SETEVENT( apply_select_item_name,  OnApplySelection,     this );
    CON_SETEVENT( select_item_mode,        OnSelectionMode,      this );
    CON_SETEVENT( select_toggle,           OnSelectionMode,      this );

    // Set the Draw Functions
    ival.intv.value = (int)&DrawSelectInfo;
    (*select_info_area->set)( select_info_area, CTL_USERDRAW, &ival );

    return true;
  } catch( bool ) {
    return false;
  }

  return true;
}