示例#1
0
Open( FrameBuf *fbuf, int w, int h )
{
   fbuf->ras = rasf->create( w, h, 0 );
   if ( !fbuf->ras )
      return "Couldn't allocate image buffer.";

   fbuf->w = w;
   fbuf->h = h;

   fbuf->panel = PAN_CREATE( panf, "FrameBuffer Demo" );
   if ( !fbuf->panel ) {
      Close( fbuf );
      return "Couldn't create frame buffer panel.";
   }

   fbuf->ctl = CANVAS_CTL( panf, fbuf->panel, "", w, h );
   if ( !fbuf->ctl ) {
      Close( fbuf );
      return "Couldn't create frame buffer canvas.";
   }

   ival.ptr.ptr = draw_canvas;
   fbuf->ctl->set( fbuf->ctl, CTL_USERDRAW, &ival );

   ival.ptr.ptr = fbuf;
   fbuf->ctl->set( fbuf->ctl, CTL_USERDATA, &ival );

   return NULL;
}
示例#2
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;
}
示例#3
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 );
}
示例#4
0
文件: dna.c 项目: DimondTheCat/xray
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 );
}
示例#5
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;
}
示例#6
0
// Constructor:
LWLister::LWLister( GlobalFunc *_global,
                    LWPanelFuncs *_panel_funcs, LWPanelID _panel, int w, int h,
                    int          (__cdecl *_count)( void *data ),
                    const char * (__cdecl *_name)(  void *data, int index, int col ),
                    int          (__cdecl *_col_widths)( void *data, int col ),
                    void * _user_data )
  : global(_global), panel_funcs(_panel_funcs), panel(_panel),
    count(_count), name(_name), col_widths(_col_widths), select(NULL),
    user_data(_user_data),
    first_visible_item(0), leftmost_visible_pixel(0), max_hscroll(500) {

  // Fetch RasterFuncs
  raster_funcs = (LWRasterFuncs *)global( LWRASTERFUNCS_GLOBAL, GFUSE_ACQUIRE );

  // Get the column count
  int value;
  for( int i=0; (value = col_widths( user_data, i)) != 0; i++ )
    column_widths.Add( value );

  // Check the interface sizes
  if( h < 45 )
    h = 45;

  if( w < 60 )
    w = 60;

  // Create the slider raster images
  vslider_raster_knob   = raster_funcs->create( 15, 1, 0 );
  vslider_raster_trough = raster_funcs->create( 15, 1, 0 );

  hslider_raster_knob   = raster_funcs->create( 1, 15, 0 );
  hslider_raster_trough = raster_funcs->create( 1, 15, 0 );

  for( double d=0; d < 15.0; d++ ) {
    raster_funcs->drawRGBPixel( vslider_raster_knob,   (int)(184 - (44 * (d/14.0))), (int)(196 - (44 * (d/14.0))), (int)(184 - (44 * (d/14.0))), (int)d, 0 );
    raster_funcs->drawRGBPixel( vslider_raster_trough, (int)(104 + (60 * (d/14.0))), (int)(104 + (60 * (d/14.0))), (int)(104 + (60 * (d/14.0))), (int)d, 0 );

    raster_funcs->drawRGBPixel( hslider_raster_knob,   (int)(184 - (44 * (d/14.0))), (int)(196 - (44 * (d/14.0))), (int)(184 - (44 * (d/14.0))), 0, (int)d );
    raster_funcs->drawRGBPixel( hslider_raster_trough, (int)(104 + (60 * (d/14.0))), (int)(104 + (60 * (d/14.0))), (int)(104 + (60 * (d/14.0))), 0, (int)d );
  }

  // Create the controls
  lister  = CANVAS_CTL( panel_funcs, panel, "", w-18, h-18 );
  vslider = CANVAS_CTL( panel_funcs, panel, "", 15,   h-18 );
  hslider = CANVAS_CTL( panel_funcs, panel, "", w-18, 15   );

  PanelTools::PutOnLineWith( lister, vslider );
  PanelTools::AlignLabels( lister, hslider );

  CON_SETEVENT( lister,  NULL, this );
  CON_SETEVENT( vslider, NULL, this );
  CON_SETEVENT( hslider, NULL, this );

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

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

  ival.intv.value = (int)&DrawLWListerHSlider;
  (*hslider->set)( hslider, CTL_USERDRAW, &ival );
}