Anonymous avatar Anonymous committed 3641027

Comments (0)

Files changed (3)

 display_message (const char *msg) {
 	int y = INFOSIZE+1, x = 0, i,n = strlen(msg);
 	move(y++,0); clrtoeol();
-	mvaddch(y,0,' ');//' 'buf[0] = ' ';
+	mvaddch(y,0,' ');
 	for (x = 1; x < COLS-1; x++) {
-		mvaddch(y,x,'-'); //buf[i] = '-';
+		mvaddch(y,x,'-'); 
         }
 	mvaddch(y++,x,' ');
 	x = 0;
 	return 1;	
 }
 
-/* FIXME: Either there is a bug here, or libparted doesn't work as expected */
 action_resize (PedPartition **part) {
 	static MenuItem part_position[] = {
 		{ 'f', N_("Fixed start"), N_("Don't move the beginning of the partition") },
 	PedSector start,end,first,last;
 	UIOpts opts = UI_WARN_COMMIT;
 	if (!((*part)->type & PED_PARTITION_EXTENDED)) {
-		menu_title(_("What do you want to do?"));
-		key = do_menu(resize_menu, 11, MENU_BUTTON | MENU_TITLE,resize_keys, 0);
+		if ((*part)->fs_type->ops->resize != NULL) {
+			menu_title(_("What do you want to do?"));
+			key = do_menu(resize_menu, 11, MENU_BUTTON | MENU_TITLE,resize_keys, 0);
+		}
+		else {
+			key = 0;
+			getbool(_("Can't resize the partition. Alter the size? (For experts only)"),&key);
+			key = (key ? 'c' : ESC);
+		}
 		if (key == ESC)
 			return 0;
 		if (key == 'r') {
 	}
 	return 1;
 }
+
 static int
 action_mkfs (PedPartition **part) {
 	char buf[SMALLBUF];
 	const PedFileSystemType *type = NULL;
 	int go;
 	if ((*part)->fs_type) {
-		go = 1;
-		snprintf(buf,SMALLBUF,_("The partition has %s set as a filesystem. Use it?"),
-		         (*part)->fs_type->name);
-		getbool(buf,&go);
-		if (go) type = (*part)->fs_type;
+		/* If we have an fs_type, we hope we can create it */
+		if ((*part)->fs_type->ops->create != NULL) {
+			go = 1;
+			snprintf(buf,SMALLBUF,_("The partition has %s set as a filesystem. Use it?"),
+			         (*part)->fs_type->name);
+			getbool(buf,&go);
+			if (go) type = (*part)->fs_type;
+		}
+		else {
+			snprintf(buf,SMALLBUF, N_("Can't create filesystem %s, you'll have to choose another"), (*part)->fs_type->name);
+			warning_waitkey(buf);
+		}
 	}
 	if (!do_mkfs (disk, *part, type, UI_WARN_COMMIT, &uiquery)) {
 		warning_waitkey(N_("Partition not formatted successfully"));
 }
 
 static int
+action_maximize(PedPartition **part) {
+	if (!do_maximize(disk,*part,&uiquery)) {
+		warning_waitkey(N_("Couldn't maximize this partition"));
+		return 0;
+	}
+	return 1;
+}
+
+static int
+action_minimize(PedPartition **part) {
+	PedPartition *temp;
+	temp = disk_get_prev_nmd_partition(disk, *part);
+	if (temp && temp->type & PED_PARTITION_FREESPACE)
+		temp = disk_get_prev_nmd_partition(disk, temp); 
+
+	if (!(*part)->type & PED_PARTITION_EXTENDED)
+		return 0;
+	if (!ped_disk_minimize_extended_partition(disk)) {
+		warning_waitkey(N_("Couldn't minimize the extended partition"));
+		return 0;
+	}
+	if (!ped_disk_extended_partition(disk)) {
+		*part = temp;
+		do {
+			temp = ped_disk_next_partition(disk,temp);
+		} while (temp && temp->type & PED_PARTITION_METADATA);
+		if (temp) *part = temp;
+	}
+	return 1;
+}
+
+static int
 action_commit () {
 	if (!do_commit(disk,&uiquery)) {
 		warning_waitkey(N_("Commit failed."));
 	}
 }
 
+/* Here we begin with flag editing */
+static void
+printaflag (int *y, const PedPartition *part, PedPartitionFlag flag, PedPartitionFlag selected) {
+	/* Yeah, I know it shouldn't be this way, but ... */
+	const struct { const PedPartitionFlag flag; const char* text; } labels[] = {
+		{ PED_PARTITION_BOOT, _("Bootable") },
+		{ PED_PARTITION_ROOT, _("Root") },
+		{ PED_PARTITION_SWAP, _("Swap") },
+		{ PED_PARTITION_HIDDEN, _("Hidden") },
+		{ PED_PARTITION_RAID, _("RAID") },
+		{ PED_PARTITION_LVM, _("LVM") },
+		{ PED_PARTITION_LBA, _("LBA") },
+		{ PED_PARTITION_HPSERVICE, _("HP Service") },
+		{ PED_PARTITION_PALO, _("Palo") }, /* What the hell is this? */
+		{ PED_PARTITION_PREP, _("Prep") }, /* Hm, ok, I retract the last question */
+		{ PED_PARTITION_MSFT_RESERVED, _("MSFT Reserved") }, /* Please, play with this on any partition you happen to find */
+		{ 0, NULL }
+	};
+	int i;
+	const char *text = NULL;
+	if (!ped_partition_is_flag_available(part,flag))
+		return;
+	move(*y,0); clrtoeol();
+	if (selected == flag)
+		attron(A_STANDOUT);
+	/* Find suitable text */
+	for (i = 0; labels[i].flag; i++) {
+		if (flag == labels[i].flag) {
+			text = labels[i].text;
+			break;
+		}
+	}
+	if (!text)
+		text = ped_partition_flag_get_name(flag);
+	mvaddch((*y),7,'[');
+	mvaddch((*y),8,ped_partition_get_flag (part, flag) ? 'X' : ' ');
+	mvaddstr((*y),9,"] ");
+	mvaddstr((*y)++,11,text);
+	if (selected == flag)
+		attroff(A_STANDOUT);
+	
+
+}
+static void
+flag_draw (const PedPartition *part, PedPartitionFlag selected) {
+
+	PedPartitionFlag walk;
+	int n,x,y = INFOSIZE;
+
+	n = LINES-MENUSIZE-3;
+
+	move(y++,0); clrtoeol();
+	move(y,0); clrtoeol();
+	mvaddstr(y++,5,_("Partition flags (press Esc two times to end)"));
+
+	mvaddch(y,0,' ');
+	for (x = 1; x < COLS-1; x++) {
+		mvaddch(y,x,'-');
+        }
+	mvaddch(y++,x,' ');
+	move(y++,0); clrtoeol();
+	printaflag(&y,part,PED_PARTITION_BOOT,selected);
+	printaflag(&y,part,PED_PARTITION_HIDDEN,selected);
+	move(y++,0); clrtoeol();
+	move(y,0); clrtoeol();
+	mvaddstr(y++,5,_("Other partition flags (for experts only):"));
+	for (walk = ped_partition_flag_next(0); walk && y < n; walk = ped_partition_flag_next(walk)) {
+		if (walk != PED_PARTITION_BOOT && walk != PED_PARTITION_HIDDEN) {
+			printaflag(&y,part,walk,selected);
+		}
+	}
+	while (y < n) {
+		move(y++,0); clrtoeol();
+	}
+	refresh();
+}
+
+static int
+action_flag (PedPartition **part) {
+	PedPartitionFlag selected = PED_PARTITION_BOOT;
+	/* This is not quite sexy */
+	/* FIXME FIXME FIXME Make this *sane* */
+	PedPartitionFlag first = 0, temp_a, temp_b;
+	do {
+		first = ped_partition_flag_next(first);
+	} while (first == PED_PARTITION_BOOT || first == PED_PARTITION_HIDDEN ||
+	         !ped_partition_is_flag_available(*part,first));
+	int redraw = 1, key = 0, done = 0;
+	while (!done) {
+		if (redraw) {
+			flag_draw(*part,selected);
+			clear_menu();
+			redraw = 0;
+		}
+		refresh();
+		key = getch();
+		if (key == ESC) {
+			key = getch();
+			if (key == '[' || key == 'O') {
+				key = getch();
+				if (key == 'B') { /* That's down arrow */
+					/* This should be replaced anyway */
+					temp_a = selected;
+					do {
+						if (temp_a == PED_PARTITION_BOOT)
+							temp_a = PED_PARTITION_HIDDEN;
+						else if (temp_a == PED_PARTITION_HIDDEN)
+							temp_a = first;
+						else {
+							do {
+								temp_a = ped_partition_flag_next(temp_a);
+							} while (temp_a == PED_PARTITION_BOOT || 
+								temp_a == PED_PARTITION_HIDDEN);
+						}
+					} while (temp_a && !ped_partition_is_flag_available(*part,temp_a));
+					if (!temp_a)
+						print_warning(_("No more flags"),0);
+					else {
+						selected = temp_a;
+						redraw = 1;
+					}
+				}
+				else if (key == 'A') { /* That's up arrow */
+					/* You are not expected to understand this */
+					temp_a = 0;
+					temp_b = 0;
+					do { 
+						if (temp_b == 0)
+							temp_b = PED_PARTITION_BOOT;
+						else if (temp_b == PED_PARTITION_BOOT)
+							temp_b = PED_PARTITION_HIDDEN;
+						else if (temp_b == PED_PARTITION_HIDDEN)
+							temp_b = first;
+						else {
+							do {
+								temp_b = ped_partition_flag_next(temp_b);
+							} while (temp_b == PED_PARTITION_BOOT || 
+								temp_b == PED_PARTITION_HIDDEN);
+						}
+						if (!temp_b || ped_partition_is_flag_available(*part,temp_b))
+							temp_a = temp_b;
+						if (temp_b == 0 && selected == PED_PARTITION_BOOT)
+							break;
+						if (temp_b == PED_PARTITION_BOOT && selected == PED_PARTITION_HIDDEN)
+							break;
+						if (temp_b == PED_PARTITION_HIDDEN && selected == first)
+							break;
+					} while (temp_b && ped_partition_flag_next(temp_b) != selected);
+					if (!temp_a)
+						print_warning(_("No more flags"),0);
+					else {
+						selected = temp_a;
+						redraw = 1;
+					}
+				}
+				else
+					print_warning(_("Invalid key"),0);
+			}
+			else if (key == ESC) {
+				return 1;
+			}
+			else
+				print_warning(_("Invalid key"),0);
+		}
+		else if (key == CR || key == ' ') {
+			do_set(disk,*part,selected,UI_FLAG_TOGGLE,&uiquery);
+			redraw = 1;
+		}
+		else 
+			print_warning(_("Invalid key"),0);
+	}
+	return 1;
+}
+
 /* Define column positions. The first three will be fixed. */
 #define col_name 3
 #define col_flags 12
 		mvaddstr(y,0,buf);
 		/* ped_partition_get_flag(part, PED_PARTITION_BOOT) throws an exception when ran on a
 		   free space. */
-		/* FIXME: This blows up on different partition types */
 		snprintf(buf, SMALLBUF, "%-*s", col_type-col_flags,
-		         (!free && ped_partition_is_flag_available(part, PED_PARTITION_BOOT) && 
+		         (0 && !free && ped_partition_is_flag_available(part, PED_PARTITION_BOOT) && 
 		         ped_partition_get_flag(part, PED_PARTITION_BOOT) ? N_("Bootable") : ""));
 		mvaddstr(y,col_flags,buf);
 
 
 		mvaddstr(y,col_fs,buf);
 		temp = NULL;
-		if (ped_disk_type_check_feature(cdisk->type,PED_DISK_TYPE_PARTITION_NAME))
+		if (ped_disk_type_check_feature(cdisk->type,PED_DISK_TYPE_PARTITION_NAME) && !free)
 			temp = ped_partition_get_name(part);
 		if (!temp) temp = "";
 		snprintf(buf, SMALLBUF, "%-*s", col_size-col_label, temp);
 	refresh();
 }
 
+
+
+
 static MenuItem main_menu[] = {
-	{ 'b', N_("Bootable"), N_("Toggle bootable flag of the current partition") },
+	{ 'b', N_("Flags"), N_("Change the flags of the current partition") },
 	{ 'n', N_("New"), N_("Create new partition from free space") },
 	{ 's', N_("Rescue"), N_("Look for deleted and corrupted partitions in the free space") },
 	{ 'f', N_("Format"), N_("Formats the partition with a filesystem") },
 	{ 'a', N_("Rename"), N_("Change partition name") },
 	{ 'y', N_("Copy"), N_("Write another partition over this one (requires commit)") },
 	{ 'r', N_("Resize"), N_("Resizes the current partition (requires commit)") },
+	{ 'x', N_("Maximize"), N_("Enlarges the partition to the maximum possible size") },
+	{ 'z', N_("Minimize"), N_("Shrinks the partition to the minimum possible size") },
 	{ 'o', N_("Move"), N_("Moves the current partition (requires commit)") },
 	{ 'd', N_("Delete"), N_("Delete the current partition") },
-	{ 't', N_("Type"), N_("Change the filesystem type") },
+	{ 't', N_("Type"), N_("Set the filesystem type (doesn't convert the filesystem)") },
 	{ 'u', N_("Units"), N_("Change units of the partition size display") },
 	{ 'w', N_("Commit"), N_("Write the changes to the disk") },
 	{ 'q', N_("Quit"), N_("Quit program without writing partition table") },
         { 0, NULL, NULL }
 };
 
-const char keys_ext[] = { 'd','u','w','q','p','h','r',UP_KEY,DOWN_KEY, '\0' };
+const char keys_ext[] = { 'd','u','w','q','p','h','r','x','z',UP_KEY,DOWN_KEY, '\0' };
 const char keys_free[] = { 'n','s','u','w','q','p','h',UP_KEY,DOWN_KEY, '\0' };
 const char keys_part[] = { 'b','f','c','a','y','r','o','d','t','u','w','q','p','h',UP_KEY,DOWN_KEY, '\0' };
 /*bfcayrodtuwqph*/
 		//redraw = 1;
 		key = 0;
 	}
+	else if (key == 'x') {
+		action_maximize(part);
+		//redraw = 1;
+		key = 0;
+	}
+	else if (key == 'z') {
+		action_minimize(part);
+		//redraw = 1;
+		key = 0;
+	}
+	else if (key == 'b') {
+		action_flag(part);
+		//redraw = 1;
+		key = 0;
+	}
 	else {
 		warning_waitkey("Unimplemented");	 /* TODO */
 		key = 0;
 /* TODO: Decide if these should be moved to UICalls */
 StrList *disk_type_list;
 StrList *fs_type_list;
+//StrList *fs_type_resize;
+StrList *fs_type_mkfs;
+StrList *flag_name_list;
+
+int
+init_flag_str ()
+{
+	PedPartitionFlag walk;
+	flag_name_list = NULL;
+	for (walk = ped_partition_flag_next(0); walk; walk =ped_partition_flag_next(walk)) {
+		flag_name_list = str_list_insert(flag_name_list, ped_partition_flag_get_name(walk));
+		if (!flag_name_list)
+			return 0;
+	}
+	return 1;
+}
 
 int
 init_fs_type_str ()
 	     walk = ped_file_system_type_get_next (walk))
 	{
 		fs_type_list = str_list_insert (fs_type_list, walk->name);
+		if (walk->ops->create != NULL)
+			fs_type_mkfs = str_list_insert(fs_type_mkfs, walk->name);
+		//if (talk->ops->resize != NULL)
+		//	fs_type_resize = str_list_insert(fs_type_mkfs, walk->name);
 		if (!fs_type_list)
 			return 0;
 	}
 	return 1;
 }
 
+
+/* FIXME: I don't like this mkfs thing this way. Find a better one. */
 static int
-get_fs_type (const char* prompt, const PedFileSystemType **value, UICalls *uiquery)
+get_fs_type (const char* prompt, const PedFileSystemType **value, int mkfs, UICalls *uiquery)
 {
 
 
 			fs_type_name = (char *) calloc(n,sizeof(char));
 			strncpy(fs_type_name,(*value)->name,n);
 		}
-		if (!uiquery->getstring(prompt,&fs_type_name,fs_type_list,NULL,-1))
+		if (!uiquery->getstring(prompt,&fs_type_name,mkfs ? fs_type_mkfs : fs_type_list,NULL,-1))
 			return 0;
 		if (!fs_type_name) {
 			ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
 	return 1;
 }
 
+static int
+get_part_flag (const char* prompt, PedPartition *part, PedPartitionFlag *value, UICalls *uiquery)
+{
 
+	StrList			*opts = NULL, *locopts = NULL;
+	char*			flag_name = NULL;
+	PedPartitionFlag	flag = 0;
+	while ( (flag = ped_partition_flag_next (flag)) ) {
+		if (ped_partition_is_flag_available (part, flag)) {
+			const char*	walk_name;
+
+			walk_name = ped_partition_flag_get_name (flag);
+			opts = str_list_append (opts, walk_name);
+			locopts = str_list_append (locopts, _(walk_name));
+		}
+	}
+	if(*value)
+		flag_name = strdup(ped_partition_flag_get_name(*value));
+	if (!uiquery->getstring(prompt,&flag_name,opts,locopts,-1))
+		return 0;
+	if (!flag_name) {
+		ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+					_("Expecting a flag."));
+		return 0;
+	}
+	flag = ped_partition_flag_get_by_name (flag_name);
+	if (!flag) {
+		ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+					_("Unknown flag \"%s\"."),
+					flag_name);
+		return 0;
+	}
+	free (flag_name);
+	
+	*value = flag;
+	return 1;
+}
 
 static int
 get_sector (const char* prompt, PedDevice* dev, PedSector* value,
 	if (opts & UI_WARN_COMMIT)
 		if (!ask_boolean_question 
 		(_("WARNING: This writes all data to disk automatically, continue?"),uiquery)) 
-			return 1;
+			return 0;
 
         if (!dst_disk)
                 goto error;
 	if (opts & UI_WARN_COMMIT) {
 		if (!ask_boolean_question 
 		(_("WARNING: This writes all data to disk automatically, continue?"),uiquery)) 
-			return 1;
+			return 0;
 	}
 
         if (!disk)
         if (!_partition_warn_busy (part))
                 goto error;
 	if (!type) {
-        	if (!get_fs_type (_("File system"), &type, uiquery))
+        	if (!get_fs_type (_("File system"), &type, 1, uiquery))
 	                goto error;
 	}
 
             /*|| (peek_word && isdigit (peek_word[0]))) {*/
                 fs_type = NULL;
         } else if (!fs_type) {
-                if (!get_fs_type (_("File system type"), &fs_type, uiquery))
+                if (!get_fs_type (_("File system type"), &fs_type, 0, uiquery))
                         goto error;
         }
         /*if (peek_word)
 	if (opts & UI_WARN_COMMIT) {
 		if (!ask_boolean_question 
 		(_("WARNING: This writes all data to disk automatically, continue?"),uiquery)) 
-			return 1;
+			return 0;
 	}
 
         if (!ped_disk_type_check_feature (disk->type, PED_DISK_TYPE_EXTENDED)) {
         }
 
         if (!fs_type) {
-                if (!get_fs_type (_("File system type?"), &fs_type, uiquery))
+                if (!get_fs_type (_("File system type?"), &fs_type, 1, uiquery))
                         return 0;
         }
 	if (!do_mkpart(disk,start,end,part_type,fs_type,&part,opts,uiquery))
 	if (opts & UI_WARN_COMMIT) {
 		if (!ask_boolean_question 
 		(_("WARNING: This writes all data to disk automatically, continue?"),uiquery)) 
-			return 1;
+			return 0;
 	}
 
 	if (!part)
 	if (opts & UI_WARN_COMMIT)
 		if (!ask_boolean_question 
 		(_("WARNING: This writes all data to disk automatically, continue?"),uiquery)) 
-			return 1;
+			return 0;
 
         if (!get_sector (_("Start"), disk->dev, &start, NULL, opts & UI_CUSTOM_VALUES, uiquery))
                 goto error;
 	if (opts & UI_WARN_COMMIT && !(part->type == PED_PARTITION_EXTENDED || (opts & UI_NO_FS_RESIZE)))
 		if (!ask_boolean_question 
 		(_("WARNING: This writes all data to disk automatically, continue?"),uiquery)) 
-			return 1;
+			return 0;
 	if (!part) 
         	if (!get_partition (_("Partition"), disk, &part, uiquery))
                 	goto error;
 }
 
 int
+do_maximize (PedDisk* disk, PedPartition* part, UICalls *uiquery)
+{
+	PedConstraint *constraint = NULL;
+	if (!disk)
+		return 0;
+	if (!part)
+		if (!get_partition(_("Partition"), disk, &part, uiquery))
+			return 0;
+	if (!_partition_warn_busy(part))
+		return 0;
+	constraint = ped_constraint_any(disk->dev);
+	if (!constraint)
+		return 0;
+	if (!ped_disk_maximize_partition(disk,part,constraint)) {
+		ped_constraint_destroy (constraint);
+		return 0;
+	}
+	ped_constraint_destroy(constraint);
+	return 1;
+}
+
+int
+do_set (PedDisk *disk, PedPartition *part, PedPartitionFlag flag, UIOpts opts, UICalls *uiquery)
+{
+        int                     state;
+
+        if (!disk)
+                goto error;
+        if (!part)
+		if (!get_partition (_("Partition"), disk, &part, uiquery))
+			goto error;
+	if (!flag)
+		if (!get_part_flag (_("Flag to change"), part, &flag, uiquery))
+			goto error;
+        state = (ped_partition_get_flag (part, flag) == 0 ? 1 : 0);
+        
+        if (!opts & UI_FLAG_TOGGLE) {
+                if (!uiquery->getbool (_("New state"), &state))
+		            goto error;
+        }
+    
+        if (!ped_partition_set_flag (part, flag, state))
+	        	goto error;
+    	uiquery->need_commit = 1;
+
+	return 1;
+
+error:
+        return 0;
+}
+
+int
 do_commit (PedDisk* disk, UICalls* uiquery)
 {
 	if (ped_disk_commit(disk)) {
 	}
 	else return 0;
 }
+
 	UI_WARN_COMMIT = 1,	/* Warn the user if the operation commits the data to the disk */
 	UI_CUSTOM_VALUES = 2, 	/* Allow the user to adjust start/end on resize, etc */
 	UI_SPECIFY_PART_TYPE = 4, /* Allow the user to specify the partition type */
-	UI_NO_FS_RESIZE = 8 	/* Resize will only change geometry, will not resize filesystem */
+	UI_FUNCTION_SPECIFIC_1 = 8 /* Option specific for each function */
 };
 
+/* Specific for do_resize: */
+#define UI_NO_FS_RESIZE UI_FUNCTION_SPECIFIC_1	/* Will only change geometry, will not resize */
+/* Specific for do_set: */
+#define UI_FLAG_TOGGLE UI_FUNCTION_SPECIFIC_1	/* Make do_set to toggle the flags */
+
+
+/* Lists. Should be initialized. */
+extern StrList *disk_type_list;
+extern StrList *fs_type_list;
+//extern StrList *fs_type_resize;
+extern StrList *fs_type_mkfs;
+extern StrList *flag_name_list;
+
+/* List init functions */
+extern int init_flag_str();
+extern int init_fs_type_str();
+extern int init_disk_type_str();
+
+/* We will also use this functions in cfdisk */
 extern int _can_create_primary (const PedDisk*);
 extern int _can_create_extended (const PedDisk*);
 extern int _can_create_logical (const PedDisk*);
 #define can_create_extended(disk) _can_create_extended(disk)
 #define can_create_logical(disk) _can_create_logical(disk)
 
+/* Main functions */
 extern int do_check (PedDisk*, PedPartition*, UICalls *);
 extern int do_cp (PedDisk*, PedPartition*, UIOpts, UICalls *);
 extern int do_mklabel (PedDevice*, PedDisk**, const PedDiskType*, UICalls *);
 extern int do_rescue (PedDisk*, PedSector start, PedSector end, UIOpts, UICalls *);
 extern int do_resize (PedDisk*, PedPartition*, PedSector start, PedSector end, UIOpts, UICalls*);
 extern int do_rm (PedDisk*, PedPartition*, UICalls*);
+extern int do_set (PedDisk*, PedPartition*, PedPartitionFlag, UIOpts, UICalls*);
 extern int do_commit (PedDisk*, UICalls*);
+extern int do_maximize (PedDisk*, PedPartition*, UICalls*);
 
 #endif
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.